{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch \n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.distributions import Categorical\n",
    "import torch.nn.functional as F\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import copy "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "# init Environment\n",
    "env = gym.make(\"CartPole-v0\")\n",
    "action_space = env.action_space.n\n",
    "state_space = env.observation_space.shape[0]\n",
    "\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "horizon_scale = 0.02\n",
    "return_scale = 0.02\n",
    "replay_size = 700\n",
    "n_warm_up_episodes = 50\n",
    "n_updates_per_iter = 100\n",
    "n_episodes_per_iter = 15\n",
    "last_few = 50\n",
    "batch_size = 256"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Behavior Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BF(nn.Module):\n",
    "    def __init__(self, state_space, action_space, hidden_size, seed):\n",
    "        super(BF, self).__init__()\n",
    "        torch.manual_seed(seed)\n",
    "        self.actions = np.arange(action_space)\n",
    "        self.action_space = action_space\n",
    "        self.fc1 = nn.Linear((state_space+2), hidden_size)\n",
    "        self.fc2 = nn.Linear(hidden_size, hidden_size)\n",
    "        self.fc3 = nn.Linear(hidden_size, action_space)\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "        \n",
    "    def forward(self, all_x):       \n",
    "               \n",
    "        out = self.sigmoid(self.fc1(all_x))\n",
    "        out = torch.relu(self.fc2(out))\n",
    "        out = self.fc3(out)\n",
    "        \n",
    "        return out\n",
    "    \n",
    "    def action(self, state, desire, horizon):\n",
    "        \"\"\"\n",
    "        Samples the action based on their probability\n",
    "        \"\"\"\n",
    "        all_x = torch.cat((state,desire*return_scale,horizon*horizon_scale), dim=-1)\n",
    "        action_prob = self.forward(all_x)\n",
    "        probs = torch.softmax(action_prob, dim=-1)\n",
    "        m = Categorical(probs)\n",
    "        action = m.sample()\n",
    "        return action\n",
    "    def greedy_action(self, state, desire, horizon):\n",
    "        \"\"\"\n",
    "        Returns the greedy action \n",
    "        \"\"\"\n",
    "        all_x = torch.cat((state,desire*return_scale,horizon*horizon_scale), dim=-1)\n",
    "        action_prob = self.forward(all_x)\n",
    "        probs = torch.softmax(action_prob, dim=-1)\n",
    "        action = torch.argmax(probs).item()\n",
    "        return action"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay Buffer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer():\n",
    "    def __init__(self, max_size):\n",
    "        self.max_size = max_size\n",
    "        self.buffer = []\n",
    "        \n",
    "        \n",
    "    def add_sample(self, states, actions, rewards):\n",
    "        episode = {\"states\": states, \"actions\":actions, \"rewards\": rewards, \"summed_rewards\":sum(rewards)}\n",
    "        self.buffer.append(episode)\n",
    "        \n",
    "    \n",
    "    def sort(self):\n",
    "        #sort buffer\n",
    "        self.buffer = sorted(self.buffer, key = lambda i: i[\"summed_rewards\"],reverse=True)\n",
    "        # keep the max buffer size\n",
    "        self.buffer = self.buffer[:self.max_size]\n",
    "    \n",
    "    def get_random_samples(self, batch_size):\n",
    "        self.sort()\n",
    "        idxs = np.random.randint(0, len(self.buffer), batch_size)\n",
    "        batch = [self.buffer[idx] for idx in idxs]\n",
    "        return batch\n",
    "    \n",
    "    def get_nbest(self, n):\n",
    "        self.sort()\n",
    "        return self.buffer[:n]\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### init replay buffer with n-warmup runs "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "buffer = ReplayBuffer(replay_size)\n",
    "bf = BF(state_space, action_space, 64, 1).to(device)\n",
    "optimizer = optim.Adam(params=bf.parameters(), lr=1e-3)\n",
    "\n",
    "samples = []\n",
    "#initial command\n",
    "init_desired_reward = 1 \n",
    "init_time_horizon = 1 \n",
    "\n",
    "for i in range(n_warm_up_episodes):\n",
    "    desired_return = torch.FloatTensor([init_desired_reward])\n",
    "    desired_time_horizon = torch.FloatTensor([init_time_horizon])\n",
    "    state = env.reset()\n",
    "    states = []\n",
    "    actions = []\n",
    "    rewards = []\n",
    "    while True:\n",
    "        action = bf.action(torch.from_numpy(state).float().to(device), desired_return.to(device), desired_time_horizon.to(device))\n",
    "        next_state, reward, done, _ = env.step(action.cpu().numpy())\n",
    "        states.append(torch.from_numpy(state).float())\n",
    "        actions.append(action)\n",
    "        rewards.append(reward)\n",
    "        \n",
    "        state = next_state\n",
    "        desired_return -= reward\n",
    "        desired_time_horizon -= 1\n",
    "        desired_time_horizon = torch.FloatTensor([np.maximum(desired_time_horizon, 1).item()])\n",
    "\n",
    "        if done:\n",
    "            break \n",
    "        \n",
    "    buffer.add_sample(states, actions, rewards)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "## OBSERVE THE WEIGHTS before training\n",
    "#for p in bf.parameters():\n",
    "#    print(p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "# FUNCTIONS FOR Sampling exploration commands\n",
    "\n",
    "def sampling_exploration( top_X_eps = last_few):\n",
    "    \"\"\"\n",
    "    This function calculates the new desired reward and new desired horizon based on the replay buffer.\n",
    "    New desired horizon is calculted by the mean length of the best last X episodes. \n",
    "    New desired reward is sampled from a uniform distribution given the mean and the std calculated from the last best X performances.\n",
    "    where X is the hyperparameter last_few.\n",
    "    \n",
    "    \"\"\"\n",
    "    \n",
    "    top_X = buffer.get_nbest(last_few)\n",
    "    #The exploratory desired horizon dh0 is set to the mean of the lengths of the selected episodes\n",
    "    new_desired_horizon = np.mean([len(i[\"states\"]) for i in top_X])\n",
    "    # save all top_X cumulative returns in a list \n",
    "    returns = [i[\"summed_rewards\"] for i in top_X]\n",
    "    # from these returns calc the mean and std\n",
    "    mean_returns = np.mean(returns)\n",
    "    std_returns = np.std(returns)\n",
    "    # sample desired reward from a uniform distribution given the mean and the std\n",
    "    new_desired_reward = np.random.uniform(mean_returns, mean_returns+std_returns)\n",
    "\n",
    "    return torch.FloatTensor([new_desired_reward])  , torch.FloatTensor([new_desired_horizon]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "# FUNCTIONS FOR TRAINING\n",
    "def select_time_steps(saved_episode):\n",
    "    \"\"\"\n",
    "    Given a saved episode from the replay buffer this function samples random time steps (t1 and t2) in that episode:\n",
    "    T = max time horizon in that episode\n",
    "    Returns t1, t2 and T \n",
    "    \"\"\"\n",
    "    # Select times in the episode:\n",
    "    T = len(saved_episode[\"states\"]) # episode max horizon \n",
    "    t1 = np.random.randint(0,T)\n",
    "    t2 = np.random.randint(t1,T)\n",
    "\n",
    "    return t1, t2, T\n",
    "\n",
    "def create_training_input(episode, t1, t2):\n",
    "    \"\"\"\n",
    "    Based on the selected episode and the given time steps this function returns 4 values:\n",
    "    1. state at t1\n",
    "    2. the desired reward: sum over all rewards from t1 to t2\n",
    "    3. the time horizont: t2 -t1\n",
    "    \n",
    "    4. the target action taken at t1\n",
    "    \n",
    "    buffer episodes are build like [cumulative episode reward, states, actions, rewards]\n",
    "    \"\"\"\n",
    "    state = episode[\"states\"][t1] \n",
    "    desired_reward = sum(episode[\"rewards\"][t1:t2])\n",
    "    time_horizont = t2-t1\n",
    "    action = episode[\"actions\"][t1]\n",
    "    return state, desired_reward, time_horizont, action\n",
    "\n",
    "def create_training_examples(batch_size):\n",
    "    \"\"\"\n",
    "    Creates a data set of training examples that can be used to create a data loader for training.\n",
    "    ============================================================\n",
    "    1. for the given batch_size episode idx are randomly selected\n",
    "    2. based on these episodes t1 and t2 are samples for each selected episode \n",
    "    3. for the selected episode and sampled t1 and t2 trainings values are gathered\n",
    "    ______________________________________________________________\n",
    "    Output are two numpy arrays in the length of batch size:\n",
    "    Input Array for the Behavior function - consisting of (state, desired_reward, time_horizon)\n",
    "    Output Array with the taken actions \n",
    "    \"\"\"\n",
    "    input_array = []\n",
    "    output_array = []\n",
    "    # select randomly episodes from the buffer\n",
    "    episodes = buffer.get_random_samples(batch_size)\n",
    "    for ep in episodes:\n",
    "        #select time stamps\n",
    "        t1, t2, T = select_time_steps(ep)\n",
    "        # For episodic tasks they set t2 to T-1:\n",
    "        t2 = T-1\n",
    "        state, desired_reward, time_horizont, action = create_training_input(ep, t1, t2)\n",
    "        input_array.append(torch.cat([state, torch.FloatTensor([desired_reward]), torch.FloatTensor([time_horizont])]))\n",
    "        output_array.append(action)\n",
    "    return input_array, output_array\n",
    "\n",
    "def train_behavior_function(batch_size):\n",
    "    \"\"\"\n",
    "    Trains the BF with on a cross entropy loss were the inputs are the action probabilities based on the state and command.\n",
    "    The targets are the actions appropriate to the states from the replay buffer.\n",
    "    \"\"\"\n",
    "    X, y = create_training_examples(batch_size)\n",
    "\n",
    "    X = torch.stack(X)\n",
    "    state = X[:,0:state_space]\n",
    "    d = X[:,state_space:state_space+1]\n",
    "    h = X[:,state_space+1:state_space+2]\n",
    "    inputs = torch.cat((state,d* return_scale,h*horizon_scale), dim=-1)\n",
    "    y = torch.stack(y).long()\n",
    "    y_ = bf(inputs.to(device)).float()\n",
    "    optimizer.zero_grad()\n",
    "    pred_loss = F.cross_entropy(y_, y)   \n",
    "    pred_loss.backward()\n",
    "    optimizer.step()\n",
    "    return pred_loss.detach().cpu().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "def evaluate(desired_return = torch.FloatTensor([init_desired_reward]), desired_time_horizon = torch.FloatTensor([init_time_horizon])):\n",
    "    \"\"\"\n",
    "    Runs one episode of the environment to evaluate the bf.\n",
    "    \"\"\"\n",
    "    state = env.reset()\n",
    "    rewards = 0\n",
    "    while True:\n",
    "        state = torch.FloatTensor(state)\n",
    "        action = bf.action(state.to(device), desired_return.to(device), desired_time_horizon.to(device))\n",
    "        state, reward, done, _ = env.step(action.cpu().numpy()) \n",
    "        rewards += reward\n",
    "        if done:\n",
    "            break \n",
    "    return rewards\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Training Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Algorithm 2 - Generates an Episode unsing the Behavior Function:\n",
    "def generate_episode(desired_return = torch.FloatTensor([init_desired_reward]), desired_time_horizon = torch.FloatTensor([init_time_horizon])):    \n",
    "    \"\"\"\n",
    "    Generates more samples for the replay buffer.\n",
    "    \"\"\"\n",
    "    state = env.reset()\n",
    "    states = []\n",
    "    actions = []\n",
    "    rewards = []\n",
    "    while True:\n",
    "        state = torch.FloatTensor(state)\n",
    "\n",
    "        action = bf.action(state.to(device), desired_return.to(device), desired_time_horizon.to(device))\n",
    "        next_state, reward, done, _ = env.step(action.cpu().numpy())\n",
    "        states.append(state)\n",
    "        actions.append(action)\n",
    "        rewards.append(reward)\n",
    "        \n",
    "        state = next_state\n",
    "        desired_return -= reward\n",
    "        desired_time_horizon -= 1\n",
    "        desired_time_horizon = torch.FloatTensor([np.maximum(desired_time_horizon, 1).item()])\n",
    "        \n",
    "        if done:\n",
    "            break \n",
    "    return [states, actions, rewards]\n",
    "\n",
    "\n",
    "# Algorithm 1 - Upside - Down Reinforcement Learning \n",
    "def run_upside_down(max_episodes):\n",
    "    \"\"\"\n",
    "    \n",
    "    \"\"\"\n",
    "    all_rewards = []\n",
    "    losses = []\n",
    "    average_100_reward = []\n",
    "    desired_rewards_history = []\n",
    "    horizon_history = []\n",
    "    for ep in range(1, max_episodes+1):\n",
    "\n",
    "        # improve|optimize bf based on replay buffer\n",
    "        loss_buffer = []\n",
    "        for i in range(n_updates_per_iter):\n",
    "            bf_loss = train_behavior_function(batch_size)\n",
    "            loss_buffer.append(bf_loss)\n",
    "        bf_loss = np.mean(loss_buffer)\n",
    "        losses.append(bf_loss)\n",
    "        \n",
    "        # run x new episode and add to buffer\n",
    "        for i in range(n_episodes_per_iter):\n",
    "            \n",
    "            # Sample exploratory commands based on buffer\n",
    "            new_desired_reward, new_desired_horizon = sampling_exploration()\n",
    "            generated_episode = generate_episode(new_desired_reward, new_desired_horizon)\n",
    "            buffer.add_sample(generated_episode[0],generated_episode[1],generated_episode[2])\n",
    "            \n",
    "        new_desired_reward, new_desired_horizon = sampling_exploration(buffer)\n",
    "        # monitoring desired reward and desired horizon\n",
    "        desired_rewards_history.append(new_desired_reward.item())\n",
    "        horizon_history.append(new_desired_horizon.item())\n",
    "        \n",
    "        ep_rewards = evaluate(new_desired_reward, new_desired_horizon)\n",
    "        all_rewards.append(ep_rewards)\n",
    "        average_100_reward.append(np.mean(all_rewards[-100:]))\n",
    "        \n",
    "\n",
    "\n",
    "        print(\"\\rEpisode: {} | Rewards: {:.2f} | Mean_100_Rewards: {:.2f} | Loss: {:.2f}\".format(ep, ep_rewards, np.mean(all_rewards[-100:]), bf_loss), end=\"\", flush=True)\n",
    "        if ep % 100 == 0:\n",
    "            print(\"\\rEpisode: {} | Rewards: {:.2f} | Mean_100_Rewards: {:.2f} | Loss: {:.2f}\".format(ep, ep_rewards, np.mean(all_rewards[-100:]), bf_loss))\n",
    "            \n",
    "    return all_rewards, average_100_reward, desired_rewards_history, horizon_history, losses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Episode: 100 | Rewards: 95.00 | Mean_100_Rewards: 37.45 | Loss: 0.57\n",
      "Episode: 200 | Rewards: 164.00 | Mean_100_Rewards: 146.84 | Loss: 0.57\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<function matplotlib.pyplot.show(*args, **kw)>"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA20AAAHiCAYAAAB7iyTuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd3yc5ZXo8d+ZIo16syTbknvBuBtsbOPFdDCdAMFAaClAYJPcDQsBEi7JEm5CNtmETcKSmHViWugECCUYTMAEMC4Ug3vHcpFk9Tb9uX+874xG0qjYlj0a6Xw/H3088847M2eUoJkz5zznEWMMSimllFJKKaX6JkeiA1BKKaWUUkop1TlN2pRSSimllFKqD9OkTSmllFJKKaX6ME3alFJKKaWUUqoP06RNKaWUUkoppfowTdqUUkoppZRSqg/TpE2pJCYiS0TkvkTHoZRSSimljhxN2pTqhIjsFJEWEWkUkf12gpSZ6LiUUkqpZGO/p56R6DiUSlaatCnVtQuMMZnAdGAGcFcighARVyKeVymllFJKJZ4mbUr1gDFmP/AGVvKGiKSKyK9E5EsRKReRP4hImn3buyJyqX35X0TEiMi59vUzRORT+/IYEXlbRKpE5ICIPCEiuZHntL+VvENE1gJNIuISkRki8rGINIjI04An5vxBIvKKiNSKSLWIvCci+t+4UkqpPktEbhCRrfb71ssiMtQ+LiLyGxGpEJE6EVkrIpPt284VkfX2e+EeEbktsa9CqSNPP9Ap1QMiUgqcA2y1D/0CGI+VxI0FSoB77NveBU6xL88HtgMnx1x/N/KwwM+BocCxwDDgJ+2e+krgPCAX67/XF4HHgHzgWeDSmHP/HSgDCoFi4IeAOZTXq5RSSh1pInIa1vvg5cAQYBfwlH3zWVjvmeOx3gMXAlX2bYuBm4wxWcBk4O2jGLZSCaFJm1Jde1FEGoDdQAXwYxER4Abg+8aYamNMA/Az4Ar7Pu/SNkn7ecz1k+3bMcZsNca8aYzxGWMqgV/HnBfxW2PMbmNMCzAHcAMPGGMCxpjngFUx5waw3vRG2Le/Z4zRpE0ppVRf9TXgT8aYj40xPqwlCHNFZCTWe1oWMAEQY8wGY8w++34BYKKIZBtjaowxHycgdqWOKk3alOraxfY3eadgvXEMwqpkpQNr7FbEWuDv9nGAD4HxIlKMVYl7FBgmIoOAE4DlACJSJCJP2a0d9cDj9uPH2h1zeSiwp10itivm8i+xKoFLRWS7iNx5mK9dKaWUOpKGEvM+ZoxpxKqmlRhj3gZ+DzwIlIvIIhHJtk+9FDgX2GUvSZh7lONW6qjTpE2pHjDGvAssAX4FHABagEnGmFz7J8ceWIIxphlYA/wf4AtjjB/4ALgV2GaMOWA/7M+x2henGmOygauxWibbPHXM5X1AiV3pixgeE2ODMebfjTGjgQuAW0Xk9F54+UoppdSRsBcYEbkiIhlAAbAHwBjzW2PM8cAkrDbJ2+3jq4wxFwFFWMsGnjnKcSt11GnSplTPPQCcCUwFHgZ+IyJFACJSIiJnx5z7LvAdWtevvdPuOlhtH41ArYiUYL8ZdeFDIAh8zx5KcglW5Q47hvNFZKyd1NUDIftHKaWU6gvcIuKJ/GAlW18Xkekikoq11OAjY8xOEZklIrNFxA00AV4gJCIpIvI1EckxxgRofb9Tql/TpE2pHrLXnT0K/F/gDqxWxBV2a+NbwDExp7+LlZQt7+Q6wH8AxwF1wKvAC908vx+4BLgeqMFalB17n3F2HI1YCd7/GGPeObhXqZRSSh0xr2F1qkR+TsJ6T30eq5tkDK3rw7OxviCtwWqhrMLqdgG4Bthpv/9+G6tTRal+TXROgVJKKaWUUkr1XVppU0oppZRSSqk+TJM2pZRSSimllOrDNGlTSimllFJKqT5MkzallFJKKaWU6sM0aVNKKaWUUkqpPsyV6AAABg0aZEaOHJnoMJRSSh0Fa9asOWCMKUx0HMlC3yOVUmpg6Or9sU8kbSNHjmT16tWJDkMppdRRICK7Eh1DMtH3SKWUGhi6en/U9killFJKKaWU6sM0aVNKKaWUUkqpPkyTNqWUUkoppZTqw7pd0yYiw4BHgcFAGFhkjPlvEckHngZGAjuBy40xNSIiwH8D5wLNwPXGmI8PNrBAIEBZWRler/dg76oOk8fjobS0FLfbnehQlFJKKaWUGvB6MogkCPy7MeZjEckC1ojIm8D1wDJjzP0icidwJ3AHcA4wzv6ZDTxk/3tQysrKyMrKYuTIkVh5oDoajDFUVVVRVlbGqFGjEh2OUkoppZRSA1637ZHGmH2RSpkxpgHYAJQAFwGP2Kc9AlxsX74IeNRYVgC5IjLkYAPzer0UFBRownaUiQgFBQVa4VRKqX4kFDaJDkEppdRhOKiR/yIyEpgBfAQUG2P2gZXYiUiRfVoJsDvmbmX2sX0HG5wmbImhv3fVl/mCIf71iU/4wYJjGF+cdUSe48F/bCXL4+LauSMpq2nmh3/9gt9fNYNsT/yW4efXlPHgO1s7fbyTxxfy4wsmUdXo4xuPrKbBG+iVON0OBz+7ZDLHj8jnxU/28Lu3txD5aJ7idPDLy6YxpTSHJz7axeJ/7kCA7542jotnlEQf4/EVu6ho8HHrmeOpbvLzf576hF9eNo3BOZ5eiVEl3gNvbebdzZW8cPOJ+vddKaWSVI+TNhHJBJ4H/s0YU9/FH/54N3T4ik9EbgRuBBg+fHhPwxhQInvzDBo0KNGhKNVnlNf5eGtDOadNKOo2aVv8zx1UNvi485wJB/Ucf/tsL3npKVw7dySffFnL8s2VbN7fwMyR+XHPf3tTBZX1Pk4+puN+mNsqm3h8xS5+cPYE3t5YwWe7aznj2GI87sOfA/XK2n38c0sVx4/I58315VQ0+Dh5vBXD61/sZ+n6/UwpzeHZ1WU0+YK0+EO8sW5/m6TtlbV72VrRyK1njmfljire23KAtWW1DM4ZfNjxqb6hONvDJ1/WsnJHNbNHFyQ6HKWUUoegR0mbiLixErYnjDEv2IfLRWSIXWUbAlTYx8uAYTF3LwX2tn9MY8wiYBHAzJkz+3zfhjEGYwwOx5EZuBkMBnG5+sRe50r1af5QCLAqbt15c/1+qhr9B520NfqCpLqdALT4redp8AY7Pb++JcCYokx+f9VxHW57Z1MF1/95Fat2VvPBtioKMlJYdM3xOByHX/H4YNublDdYrczl9V4mDc2OxrDggeWsLasjEAqzfl89180dwcb9DZTVtLR5jAONfg40+qlrCbCtsgmAJn/nr1Uln6/MKOE//76RP72/Q5M2pZRKUt1mIPY0yMXABmPMr2Nuehm4zr58HfBSzPFrxTIHqIu0USabnTt3cuyxx3LLLbdw3HHH8dhjjzF37lyOO+44vvrVr9LY2MjKlSu55JJLAHjppZdIS0vD7/fj9XoZPXo0AA8//DCzZs1i2rRpXHrppTQ3NwNw/fXXc+utt3Lqqadyxx13UFVVxVlnncWMGTO46aabMMbKZZuamjjvvPOYNm0akydP5umnn07ML0SpPsAfNPa/4W7PrWkK0OzvPrlrr8kXpNlnJS6RBKa+i5bGem+Q7LT4rZMnjMrH7RTe33aA97ceYM6Ygl5J2ACKslKpqLeTtgYvxdmtLY1TS3P4fE8dm/Y34A+GmVKaS2leOntq2yZtVY0+AHYcaGLHATtp87X+zowxXPTg+7y6Nin/jCvA43Zy1ezhLF1fzuuf7+MXf98Y/f+NUkqp5NCT0s484BrgcxH51D72Q+B+4BkR+SbwJfBV+7bXsMb9b8Ua+f/1ww3yP/62jvV76w/3YdqYODSbH18wqdvzNm3axJ///GfuvfdeLrnkEt566y0yMjL4xS9+wa9//Wt++MMf8sknnwDw3nvvMXnyZFatWkUwGGT2bGto5iWXXMINN9wAwN13383ixYv57ne/C8DmzZt56623cDqdfO973+Nf/uVfuOeee3j11VdZtGgRAH//+98ZOnQor776KgB1dXW9+rtQKpkEQlay5utB0lbV5I9++XEwmnwh0lOsxKW5B5W2hpYAw/LS4t6WnuJixrA8nl9TxoFGP/PG9F67c3G2h/J6H8YYyut9DI5J2qaU5vLM6jLeWLcfgKklOeyubqa6yU+zP0h6iotgKExNs5WMbq9sZHtlIwDNMZW2em+Qz3bXsraslvOmHvRMKdVHXDt3JH98dzs3P2HtwFOUlcrX5+mEYKWUShbdJm3GmH8Sf50awOlxzjfAvx5mXH3GiBEjmDNnDq+88grr169n3rx5APj9fubOnYvL5WLs2LFs2LCBlStXcuutt7J8+XJCoRAnnXQSAF988QV33303tbW1NDY2cvbZZ0cf/6tf/SpOp9WGtXz5cl54weo+Pe+888jLywNgypQp3Hbbbdxxxx2cf/750cdVaiBqTdq6rqAZY6hp9pPqOriWZn8wjD8UjiYukX+7StrqWgLkdFJpAzhxbAErd1YDMG9s77WnFWensmFfPXUtAfzBMEWxlbaSHACeWrWbbI+LEQXplORaieXe2hbGFmVR3eyPnr+9sontdqWtMabSVtNkndPg05bJZFac7eE/L5tKoy/If/xtPQfsCqtSSqnkkBSLqHpSETtSMjIyAOsD4JlnnsmTTz7Z4ZyTTjqJ119/HbfbzRlnnMH1119PKBTiV7/6FWC1Qb744otMmzaNJUuW8M4773R4/Ih4A17Gjx/PmjVreO2117jrrrs466yzuOeee3rxVSqVPCJtkd21R9Z7g4TChpZACGNMj6fmNfkiyVr7Slv89khjDPXeQKftkQDzxg7igbe2UJKbxvD89B7F0RPF2R4ONPrYW+u1r6dGb5swJAu3U6hs8PEvYwchIpTY1cCyGitpO9DQmrSt2VVDrV11a45J0GrsxK6xi6RVJYdLjisFrOmolQ2atCmlVDI5MlM1+qE5c+bw/vvvs3WrNda7ubmZzZs3AzB//nweeOAB5s6dS2FhIVVVVWzcuJFJk6xks6GhgSFDhhAIBHjiiSc6fY758+dHb3/99depqakBYO/evaSnp3P11Vdz22238fHHHx/Jl6pUn+bvYXtktV0hMqZnrZQRjXbC4guGraSvm/ZIbyBMIGQ63Q4AYFppLlkeFycfU9irI9eLsj2EDazfZ7WPx65pS3U5mTA4G4AppVbVLVJpiwwjqWqyPrjnpLmjlUCApph1gNGkTStt/UZhVqombUoplWSSotLWFxQWFrJkyRKuvPJKfD7rze6+++5j/PjxzJ49m/LycubPnw/A1KlTKSoqin44++lPf8rs2bMZMWIEU6ZMoaGhIe5z/PjHP+bKK6/kuOOO4+STT45uhfD5559z++2343A4cLvdPPTQQ0fhFSvVNwVCPRtEEknawJoA6bGnQXYndnJisz8YTWA6q7RFBpRkp3X+5zTF5eDl7/wLBZkpPYqhp4qzrMra52W19vW2e6tNsYeRRFoli7M9uBwSHUZS1Wj9jmaNzOOtDdYA4BSnI1ptBGuYC3T++lXyKcryUNGgg0iUUiqZaNLWhZEjR/LFF19Er5922mmsWrWqw3lpaWnRRA6IDhCJuPnmm7n55ps73G/JkiVtrhcUFLB06dLo9d/85jcAnH322W3WwSk1kPV0EElNbNIWCJHXw8ePTVha/CFaulnTVt9iJ21dVNoARg3K6PL2QxGprK3dYw0nKoppjwSYPSqfZ1fvZvrwXACcDmFIroc9dqUtsq7phFH5vLWhghSng9GFGW0GkUQqbV2t6VPJpTAzlS/26EArpZRKJpq0KaWSSk/XtFW3S9p6KnYIR5M/FB1/32nSFq20dZ20HQmRpG393npy0twdqokXThvK7FEFDM5prcCV5KZFK20HGv2kOB1MK7WSuhEF6WR73G1G/mt7ZP9TmJVKVZOfUNjg7KXtJ5RSSh1ZuqZNKZVU/D2cHhk7GbHlIPZqi620NfuDNNsJX2f7tNW3WOdne47+d2CDMlMQsaqOxe2qbGANNopN2ABKctOjlbaqRh8FmSmMLswEYHRhBumpzjYtotV2e6Qmbf1HYVYqobCJJuRKKaX6Pk3alFJJ5VDaI70HVWk7uPbIOrs9squR/0eKy+lgUKaVrMUOIelKSV4a5Q1e/MEwVU1+CjJTGJSZwriiTGaPKiAjxdUmca2NmR55KHveqb6n0F4LqcNIlFIqeWh7pFIqqQSCPUvaqg6xPTI2YYltj+y00pbA9kiwxvxXNvgoyupZ0laam4YxsK+uhQONPgoyUhER3rz1ZAA27q+PbnMArW2mwbDBFwz3eKCL6rtik7Zjdb90pZRKClppU0ollZ5Oj6xp8kfX6zQfYntkiz8YTfgafUHC4Y6VpsggkqwEtEdC68TIeO2R8UT2attT00JVoz9aqYtIT3G1qTZG9m6DzhNXlVwKM7XSppRSyUaTNqVUUunxPm3NfgbbLYMH1x4ZM4jEF6LJF8TpEIxpux1ARL03iMftINWVmApUUXYkaetZpW1ckbV+7ZPdtRxo9DGo3TYEGalOmv2haCtkdbOfNLu6phtsW0RkgYhsEpGtInJnJ+dcLiLrRWSdiPwl5vhwEVkqIhvs20cerbgjopW2Rk3alFIqWWjSluQWLFhAbm4u559/fpvjO3bsYPbs2YwbN46FCxfi91stTj6fj4ULFzJ27Fhmz57Nzp07ExC1UoeudXpkN4NImvzRzaQPdRBJkz+ILxiOVibirWurbwl0O+7/SIpU2HpaaSvK9jC5JJuXP92LLxjusHdcRqqLkN0KaYyhttnPsHzr96jDSEBEnMCDwDnAROBKEZnY7pxxwF3APGPMJODfYm5+FPilMeZY4ASg4qgEHiMj1UV6ivOwKm23PfsZNz++phejUkop1RVN2o6yUKjnHx574vbbb+exxx7rcPyOO+7g+9//Plu2bCEvL4/FixcDsHjxYvLy8ti6dSvf//73ueOOO3o1HqWOtJ4OIqlu8jM016o+Heyatrx0Kwk7YG8+XWxPYIybtHkDCVvPBq0VtqIeVtoAzji2mE3lDQAd2iMzUqw2zyZfkEZfkEDIMCwvHdBKm+0EYKsxZrsxxg88BVzU7pwbgAeNMTUAxpgKADu5cxlj3rSPNxpjmo9e6K0Ks1IPOWkLhQ1vrNvPWxvK23zJoZRS6sjRpK0bF198MccffzyTJk1i0aJFPPTQQ/zgBz+I3r5kyRK++93vAvD4449zwgknMH36dG666aZogpaZmck999zD7Nmz+fDDD7n33nuZNWsWkydP5sYbb4y2Ia1atYqpU6cyd+5cbr/9diZPngxYid7tt9/OrFmzmDp1Kn/84x+jz3/66aeTlZXVJmZjDG+//TaXXXYZANdddx0vvvgiAC+99BLXXXcdAJdddhnLli3TiXAqqfQkaQuEwjR4g9H1Wwe3T1swmshENp8enB2ptHVc01XfEkzIuP+I+eML+cqMEiYOye7xfc44tjh6uaDDmjarFbLZH4quZxuWbyVtDfoBHaAE2B1zvcw+Fms8MF5E3heRFSKyIOZ4rYi8ICKfiMgv7crdUVeYeehJ28b99TR4rYT+w21VvRyZUkqpeJJjeuTrd8L+z3v3MQdPgXPu7/a0P/3pT+Tn59PS0sKsWbNYtmwZ8+bN4z//8z8BePrpp/nRj37Ehg0bePrpp3n//fdxu93ccsstPPHEE1x77bU0NTUxefJk7r33XgAmTpzIPffcA8A111zDK6+8wgUXXMDXv/51Fi1axIknnsidd7Yuk1i8eDE5OTmsWrUKn8/HvHnzOOussxg1alTcmKuqqsjNzcXlsv7nLS0tZc+ePQDs2bOHYcOGAeByucjJyaGqqopBgwYd4i9SqaOrJ5trR8b9D85JwyEH2R7pD5LlcZHmdnKgIZK0dV5pq2sJdFgXdjSV5Kbxm4XTD+o+k4ZmMyTHw746LwUZbWPPTLUrbf4gvoD1Ox4eSdq00gYQbzfq9t98uYBxwClAKfCeiEy2j58EzAC+BJ4GrgcWd3gSkRuBGwGGDx/eO5HHKMxKZUtF4yHdd+WOagBSnA7e3VzJGROLu7mHUkqpw6WVtm789re/Zdq0acyZM4fdu3ezY8cORo8ezYoVK6iqqmLTpk3MmzePZcuWsWbNGmbNmsX06dNZtmwZ27dvB8DpdHLppZdGH/Mf//gHs2fPZsqUKbz99tusW7eO2tpaGhoaOPHEEwG46qqroucvXbqURx99lOnTpzN79myqqqrYsmVLpzHHq5yJSLe3KZUM/Pb0yK42145srF2QkUKa23lQSVujLxRd8xOptEVaD+NNT0x0e+ShEJFota3D9MjU1vbIyObLkaStUadHglVZGxZzvRTYG+ecl4wxAWPMDmATVhJXBnxit1YGgReB4+I9iTFmkTFmpjFmZmFhYa+/iKLDaI9cuaOa0rw0Tho3iOVbKns5MqWUUvF0W2kTkT8B5wMVxpjJ9rGngWPsU3KBWmPMdHsK1gasNyiAFcaYbx92lD2oiB0J77zzDm+99RYffvgh6enpnHLKKXi9XhYuXMgzzzzDhAkT+MpXvoKIYIzhuuuu4+c//3mHx/F4PDidVgeM1+vllltuYfXq1QwbNoyf/OQneL3eLlsUjTH87ne/4+yzz+5R3IMGDaK2tpZgMIjL5aKsrIyhQ4cCVtVt9+7dlJaWEgwGqaurIz8//xB+O0olRqQ90m8Pyoj3pUNkb7G89BTSUpwHvaZtaI6HtBRn65q2LiptiR5EcqhunD+aIbmeDgNMMuz2yCZfKJq0RdojdRAJAKuAcSIyCtgDXAFc1e6cF4ErgSUiMgirLXI7UAvkiUihMaYSOA1YfdQij1GYlUpdSwBfMHRQk0+NMazcUc3JxxQyfVguyzZW8Ob6cvbWtvDVmaWkpyRHA49SSiWbnlTalgALYg8YYxYaY6YbY6YDzwMvxNy8LXJbryRsCVRXV0deXh7p6els3LiRFStWAHDJJZfw4osv8uSTT7Jw4ULAWlv23HPPUVFhDQKrrq5m165dHR7T6/UCVmLV2NjIc889B0BeXh5ZWVnR53jqqaei9zn77LN56KGHCASsb7k3b95MU1NTp3GLCKeeemr0sR955BEuushaJ3/hhRfyyCOPAPDcc89x2mmnaaVNJZVI0hY21obP8USStvyMFDzug0/aMlJdZKS4Yta0xU/ajDHUe4NkpyXfB9Vh+enccsrYDv/9Z9iVtmZ/kJom629OcXYqKS6HrmkD7ArZd4A3sL6kfMYYs05E7hWRC+3T3gCqRGQ98A/gdmNMlTEmBNwGLBORz7FaLR8++q+itXq8raLz95J4tlU2UdXkZ/aofOaPsyqANzy6mh+/vI6bHlvTZQVcKaXUoev2k4YxZnln+8iI9W5/Oda3hf3OggUL+MMf/sDUqVM55phjmDNnDmAlWBMnTmT9+vWccMIJgLVO7b777uOss84iHA7jdrt58MEHGTFiRJvHzM3N5YYbbmDKlCmMHDmSWbNmRW9bvHgxN9xwAxkZGZxyyink5OQA8K1vfYudO3dy3HHHYYyhsLAwOljkpJNOYuPGjTQ2NlJaWsrixYs5++yz+cUvfsEVV1zB3XffzYwZM/jmN78JwDe/+U2uueYaxo4dS35+fpvkUKlkELuWzR8M43Z2/O4psqYtL8NNmtt5kPu0BclMdZGW4oxuyp2X4cblkA6DSJr9IUJhk5SVts5Epkc22pU2h0C2x01WqkunR9qMMa8Br7U7dk/MZQPcav+0v++bwNQjHWN3Tp9QRJrbyf/+czu/vrznayLf2WR9MXnCqAJGDsrg1jPHk5Hqwinwk7+t547n1vLAFTOOVNhKKTVgHe7XwycB5caY2AVWo0TkE6AeuNsY895hPkfCpKam8vrrr8e97ZVXXulwbOHChdHKW6zGxraLve+77z7uu+++DudNmjSJtWvXAnD//fczc+ZMABwOBz/72c/42c9+1uE+770X/9c7evRoVq5c2eG4x+Ph2WefjXsfpZJBpNIG1gTJjDjbkzXZyVZWqpv0lJ6vaTPG2JU2JxmprS1jGSkusjyuDpW2yBq3ZFvT1pX01Mj0SGtNW256Cg6HkBnn9avkVZCZypUnDOeRD3fy/TPGR1tgu/JlVTO/eXMzs0flM7LAOv97p4+L3r6zqpklH+zk/kun4nEnZrN5pZTqrw53EMmVwJMx1/cBw40xM7C+YfyLiMSdQy0iN4rIahFZXVmpC5kBXn31VaZPn87kyZN57733uPvuuxMdklJ9TmQQCXQ+QTJSIUt1OfC4Wytm3fEGwoSN1SKY5m79Tis9xUmWx02DN0CDNxCt3NW3WElMTj9K2qLTI30hapoC5Np71mV5XLqmrZ+5cf5oHAJ/XL6t23ODoTDff+ZTHA7hvy6fFretfnKJ1R1SXu/t9ViVUmqgO+SkTURcwCVYI4sBMMb4jDFV9uU1wDasBdgdHOnJWMlo4cKFfPrpp3zxxRe8+uqr6O9FqY4CwdhKW/xkzBsIkeZ24nAIaSldt0dWNviiyV8kKcm0p0dGpKdalbaa5gAXPfg+333yE8Aa9w/0q/bIVJcDh1hr+w40+shPt7YEyNT2yH5ncI6HC6eV8OIne9tUsOP529q9rNlVw39cOInSvPhVuSH2JvT76jRpU0qp3nY4lbYzgI3GmLLIAREpjGwUKiKjsUYcbz+8EJVSqlXsh8vOKm0t/hBpdtKV1sUgkmAozBm/fpfHVlhDg5rspC0jxdWmPTLN7STL4+KDbQfYXtnEm+vL2VzeQH0kaUvCQSSdEREyUlw0+YNsq2xi1KAMADJT3TqIpB86c2IRjb4gn+6uBeDjL2sItkvgjDH84Z3tjC/O5OLp7fcRbzXYTtr2a9KmlFK9rtukTUSeBD4EjhGRMhH5pn3TFbRtjQSYD6wVkc+A54BvG2OqDzW4rsbgqyNHf++qL/O3W9MWT7PfqrRB10nbgUY/dS0B9tS0AK2Vttj2SI/bgdMhZHncBEKG0rw00txO/vjudl76zNqeqyjL0zsvro/ISHWxp6aFA40+xhdnAZH2SN2nrb+ZO2YQDoHlmyv5YOsBLvmfD3j1831tzvnHpgo2lTdw0/wxOBydTxuOTM32kL0AACAASURBVFnVSptSSvW+nkyPvLKT49fHOfY81hYAh83j8VBVVUVBQYGOpD+KjDFUVVXh8fSvD6Gq//AHw3jcDryBcNftkXalzZPipMUfP7mLrL2JJCNNMe2RkUpbZN+pLI/177dPHsOW8gYe+dCqzt1+9jHRCkN/kZ7qjFZexhZnAtbvRAeR9D85aW6mD8tl+ZYDbC5vAGDDvgYuihko+Yd3tzM0x8OF04d2+VgZdhvx/rqWIxmyUkoNSH22p6e0tJSysjJ0SMnR5/F4KC0tTXQYSsUVCIXJTHXhDfi7qLQFo5W29C5G/keStkgy0uSPVNqc0aQvsrZtZEEGJblpXHZ8KZUNPp7/eA9XzBrGLaeM6b0X10dkpLjYXmnt39Wm0uYNdrqhuUpe88cX8t/LtvCF/b/rFjt5AyiraWbljmp+sOCYuNtrtDckx6OVNqWUOgL6bNLmdrsZNWpUosNQSvUxgZAhM9XFgcbOk7aWmEqbtd9a/GSjvMHaPDuStDX6rOQuM9VFurtt0vbd08Zy4/zReNxOhuWns/ruM/rtWPNIlTEjxclQu4qY6XERDBt8wXC/fd0D1UnjCnngrS2EMcwYnsvmitakbem6cgDOmTykR481OCeN/To9Uimlet3hjvxXSqmjyh8Mk2m3KnY5iMROLDxuJ2HTdi1cREWk0ma3RTbFrGlLt0ffp9ntkSLSJlnpz4lLZIPtscVZ0UQ3y/59aItk/zOtNIe8dDenTyjm1GOKKKtpodmuOi9dv5/xxZnRgTTdGZLt0UEkSil1BPTZSptSSsUTaY+EzgeRtARCDIkZRALg9YdJdbVNtFrbI9uuacuIGfmfkdJ/k7PORBLW8UWZ0WORRLnRF6QwK86O5ippuZwOnr/5RPIzUvhwWxXGwLaKJkry0li5o5pbThnb48canOOhstFHIBTuUTulUkqpntGkTSmVVPyhMJmp1r5onVbaAqFo0hVpk2wJhMih7X5q5fXt2yMjI/+d0funD8CkLdNujxxXHJO02b/zSIKr+pfRhdb/1uPsNYxbKhrYuL+esIGzJw3u8eMMyfFgDFQ0+CjJTTsisSql1ECkSZtSKqkEQuHoJMfOpke2+EN4UtpW2uKN/a+w17RFNo2ubwmSnuLE5XREp0ZG/h1IIq858gEeIC/dzdAcD8GwbgnSn40oSMftFDaXN/LZ7lqG5niYXJLd4/u37tXWokmbUkr1ooH3aUQpldT8wdb2yJ6saYtU2iJrdGJF1rS1BEIEQmFqm/3kpacADOhKW6QldFxMe+TMkfl8cNfpiQpJHSVup4PRgzL56ydllNf7uOf8iQc1LXRIjpWo6QRJpZTqXZq0KaWSRihsCBtrzRnEX9NmjKE5tj0ysqatXaXNHwxT1eQnN91NbXOAJl+Q6mY/eRlWG+BArrSdOqGIyka/VkoGqLHFmby6dh8luWl8bc7wg7pva6VNkzallOpNukpYKZU0AvYEyMiaq3iVNl8wjDGt0x2ja9rabbBd2Wi1Ro611/I0eIPUNAe00gbMGJ7Hzy+ZovuxDVDji6y22FvPHN9heE93sj3WEB+ttCmlVO8aeF8hK6WSVmRsv8ftxOmQuGvaIhW19pW29mvaIpMjxxRmsnpXDfXeALXNfkbkpwOtY+/TBmDSpga2y2aWkuJycPGMkoO+r4gwOMfD0vX78QZC3Dh/NCMKerZdgFJKqc5ppU0plTQCdmUt1eUg1eWIW2lr9lvJWew+bdAxaYusZ4tMSGz0Bqlu8pOfYVXactLd/PDcCVw4begReCVK9V0luWncfMoYnI5Dq7ReMqMEt9PBU6t28+f3d/ZucEopNUBp0qaUShqRSpvb6SDF5Yi7pi2SnKW1G/nv9bevtFntkWPsYRs1zQEavEFy01u3Bbhx/hiG2ZU3pVTPfOe0cbz976cwd3QBK7ZXJTocpZTqFzRpU0oljUDQGjfvdlqVNl8gTtLWrtKW7o4/PbK83ovbKQy3k7KymmaAaKVNKXV45ozOZ+P+Bqqb/IkORSmlkp4mbUqppBGttLkcpLqc0euxOqu0tbRL8MrrfRRlecj2WJW1L6utpC03XZM2pXrD3DEFAKzcodU2pZQ6XJq0KaWSRmR6ZIpT7PbIjoNI2lfaUl3Wn7n2a9p2VTVRlJ0a3ag7krTla9KmVK+YUpJLmtvJiu3ViQ5FKaWSXrdJm4j8SUQqROSLmGM/EZE9IvKp/XNuzG13ichWEdkkImcfqcCVUgNPZPBISk8GkdgVNhEhM9VFZYMves6+uhbWfFnDyeMLSXU5cDslptLm7vCYSqmDl+JyMHNkHh9u00qbUkodrp5U2pYAC+Ic/40xZrr98xqAiEwErgAm2ff5HxHRedlKqV4R6MEgksjI/0ilDeCkcYN4c/3+6P1f/GQvxsBXZpQgImR53JRVtwC6pk2p3jRndAGbyhuoavR1f7JSSqlOdZu0GWOWAz3tbbgIeMoY4zPG7AC2AiccRnxKqX7OGMP6vfU9Ojd2emRqJ0lbpNKWntK6DeUlx5VyoNHPe1sqMcbwwsdlzByRF90/KjPVFX3sPG2PVN0QkQV2N8lWEbmzk3MuF5H1IrJORP7S7rZsu1vl90cn4sSZP64QgGUbKxIciVJKJbfDWdP2HRFZa7dP5tnHSoDdMeeU2cc6EJEbRWS1iKyurKw8jDCUUsnsox3VnPvb91i3t67bcwOh1umRKS5n1yP/YyptJ48vJC/dzfMf7+Gzsjq2VDTyleNa/zRF1rV53A7dTFt1ye4eeRA4B5gIXGl3mcSeMw64C5hnjJkE/Fu7h/kp8O5RCDfhJpdkU5qXxmuf70t0KEopldQONWl7CBgDTAf2Af9lH4+3E6eJ9wDGmEXGmJnGmJmFhYWHGIZSKtmV25tcl9W0dHuuvweba0faIz0prX/eUlwOLpw2lDfXlfO1h1eQleri/Cmtm2ZnplpJm1bZVA+cAGw1xmw3xviBp7C6TGLdADxojKkBMMZEy0wicjxQDCw9SvEmlIhw3pQhvL/1AHXNgUSHo5RSSeuQkjZjTLkxJmSMCQMP09oCWQYMizm1FNh7eCEqpfqzeq+1f1pVY/d7OXVc09ZxemSzP4jTIaQ42/55WzhrOADzxxfy0nfmkRMzcCTLHvuvSVsX/M3w+XMQGvAfvHvSUTIeGC8i74vIChFZACAiDqwvOW/v7kn6UzfKuVOGEAgZlq7fn+hQlFIqabm6P6UjERlijIn0OnwFiEyWfBn4i4j8GhgKjANWHnaUSql+q77FSgJ6MqigNWmTTittLf4waW4nIm0L/xOHZrPu3rNxOzt+VxVpj8zL0MmRHQR98OY98MkT4G+A1GwYf1aio0qknnSUuLDe/07B+vLyPRGZDFwNvGaM2d3+/58dHtCYRcAigJkzZ8btWEkWU0tzoi2SX505rPs7KKWU6qDbpE1EnsR64xkkImXAj4FTRGQ61hvVTuAmAGPMOhF5BlgPBIF/NcZ0/CpcKaVs9V47aWvqvtIWSdKsQSSdrWkLdrouLV7CBjFJm1ba2gp44ZlrYcsbMPUKOO4aGH5ioqNKtJ50lJQBK4wxAWCHiGzCSuLmAieJyC1AJpAiIo3GmLjDTPoLEeHMicU88dGXhMIGp6PrhFUppVRH3SZtxpgr4xxe3MX5/w/4f4cTlFJq4Giw2yMre1RpswoOXa1pa/GH2gwh6QlN2uKo2QV/vQm+/BDO/w3M/EaiI+orVgHjRGQUsAdrm5ur2p3zInAlsEREBmG1S243xnwtcoKIXA/M7O8JW8TEIdn4g2F2VTUxujAz0eEopVTSOZzpkUopddgOpj3Sb69hax35H29N28EnbZmp9po23aPNqq598Ht46ETY/wVculgTthjGmCDwHeANYAPwjN1lcq+IXGif9gZQJSLrgX8AtxtjBvQO0+OLswDYXN6Y4EiUUio5HdKaNqWU6i0NBzWIxB7572rdXNsY02b9WksgdNBj+1srbQN8TdvWZfDy96C+DMacDhc8ALnDEx1Vn2OMeQ14rd2xe2IuG+BW+6ezx1gCLDkyEfY9Y4us6trm8gYWTB6c4GiUUir5aKVNKRVXWU0zP3jus7jVrN50UGva2g0iMQaC4bYzGryBQ2+PzB+olbZQEN74ETx+CaRmwrUvwzUvaMKmek1Gqoth+WlsLm9IdChKKZWUNGlTSsW1bEMFz6wuY8sRbmeKtEfWNPsJhjquUYsVmR6ZYo/8BzoMI2n2H3qlLXcgrmnzN8HTX4MPfw+zboAb34HRJyc6KtUPjS/KOuJ/T5RSqr/SpE0pFdeeWmuz6+oeVMAOR4M3iAgYA9XNXT+XPxjG7RREhFSXM3os1qG0R84amc81c0Ywc0TewQWf7BorYMn5sGUpnPdfcN6vwJ2W6KhUPzWuOIvtBxqjX74opZTqOU3alFJxldU0A0cmafv10k38btkWwGqPLM2zEoXu1rUFQuHo2P5Uu9J21m+Wc9uzn0XPObTpkW5+evFkMlIH0DLffWvhf8+Aig2w8AmY9a1ER6T6ufHFmQRChp0HmhIdilJKJR1N2pRSce2psSptB3ow1fFgPbO6jNe/2I8/GMYbCDNqkDWkoPukzUSTtlMnFHHt3BEUZ6fyt8/2ErLXtrUEQqQfZKVtQPHWw+t3wqKTIdAC178KE85NdFRqANAJkkopdeg0aVNKxXWk2iNrmvzsr/dS0eClwR5CMqogHeiYIH7yZQ2zf/YWv166iUZfEH9Mpa0428O9F03murkj8QXD7K62KoOHUmkbMDb8DX4/Cz76Axx/PXxnJZQen+io1AAxtigTh6DDSJRS6hBo0qaU6sAbCHHArnr1dtK2YV89AAca/dHHHjUowz7WNml7Ze0+Kht8/PbtrVz18Ar8wXC0LTJiXHHrKPFQ2OALhvFo0tbRyofh6ashswi+tczaMDttgK3hUwnlcTsZWZDBh9sH9JZ1Sil1SDRpU0p1EKmyQc9G8R+M9XbSBrCt0lrbUpqXjtspHZ7r/a0HmDO6gO+fMZ61ZXVUNvhwO6XNOZH9n7ZUNOINWNsTaHtkjKAPlv0UXrsNjjkPvvWWVtdUwnxtzghW7qjmvS2ViQ5FKaWSiiZtSqkOyuz1bB63g6peXtO2YV9ra9TWCutydpqbgozUNs91oNHHxv0NzBs7iGnDcgD4fE9dtD0yIsvjZmiOhy3lDTT7raTtYKdH9lsVG+GP8+G9X8H0q+HyR8CVmuio1AB29ZzhlOalcf/rGwm322NRKaVU5zRpU2qA2l/n7XT0dmQIyaShOb3eHrlxfz2DMq3EYWuFNZAgO81FQWZKtCUT4MNtVgvViWMKmDgkG7BaNdsnbQBji7PaVNq0PRLY+yn8+RxoqYGrnoWLHwSnO9FRqQEu1eXktrOOYd3eepau35/ocJRSKmlo0qbUAOQLhjjtv97huTVlcW/fU9uMyyFMHJLdq+2RgVCYLeWNnDy+ELBaGsGqlhVktq20fbDtAFmpLqaU5FCYlUpBhrXxdYqr45+t8UWZbK1oZIc9SjwnbQAnJ+EwrHkEHrkAUjLhG3+H8WclOiqloi6YNpSMFCcfbNO1bUop1VOatCk1AHkDYZr9oWhFrb09NS0MzvFQmJVKgzfYYQPrQ7W9sgl/KMy8sQU4HcK2SrvS5nExqF2l7YNtVcwenY/L6UBEmDDEGheeEqfSNq44E18wzM9e20B+RgrzxxX2SrxJp+kAPHYR/O17MHgqfON1yB+d6KiUasPpECaV5PBZWV2iQ1FKqaTRbdImIn8SkQoR+SLm2C9FZKOIrBWRv4pIrn18pIi0iMin9s8fjmTwSqlDE7TbIuvtkfvt7altoSQ3jXy7utVbLZKRyZGThuZQlJWKNxDGIZCR4mJwtoeKBi/eQIiymmZ2VTVz4phB0fseO9hqkXS7pMPjjrP3f9q4v4Fr5owYmGva9n8BD58Ku1fCBf8N178COaWJjkqpuKYPy2XD3vpe+0JIKaX6u55U2pYAC9odexOYbIyZCmwG7oq5bZsxZrr98+3eCVMp1ZuC9gCAupb4SVtZTQsleWkMyrSStqqm3hlGsqvK2kttdGEGRVnWurbMVBcOhzBrZD6BkGHNrho+2Gq1Tc0bG5O02eva4q5psydIprocXDt3RK/EmlQ2vAKLz4JQAL7+mrUHm3RMbpXqK6aW5uAPhdm4v777k5VSSnWftBljlgPV7Y4tNcYE7asrAP06V6kkEkna6uMkbYFQmPJ6L6W5aeRnWIlVb1XaAqEwLofgdjooyvYA1uRIgFmj8nE5hPe3HuD9bQcYlJnKeHsPNmhN2uK1R2Z73EwpyeH6E0dSkDnApiN+8Ht4+mtQNAFu+AeU6Dh/1fdNK80F0BZJpZTqIVcvPMY3gKdjro8SkU+AeuBuY8x7vfAcSqle1NoeGexw266qZsIGhhdk9Hp7ZDBscDqsClBxtpVcZXmspC0z1cW0Ybm8v/UAe+u8nDimAImpFo0pyrASvjiDSABe/s68XokxaRgDb/5f+OB3MPEi+MofwZ2W6KiU6pHSPKv9eu3uWpgzAKvjSil1kA5rEImI/AgIAk/Yh/YBw40xM4Bbgb+ISHYn971RRFaLyOrKSt1kU6mjqatK2+d7agGYUpITbY+MHRByOEJhq9IGUJxlV9o8rd8dzRtTwGf2Jtrzxha0uW+qy8m5U4YwY1hu3McWkTZJXr9mDLzxQythm/UtuOzPmrCppCIiTCvN4bOy2kSHopRSSeGQkzYRuQ44H/iaMcYAGGN8xpgq+/IaYBswPt79jTGLjDEzjTEzCwsH6KQ3pRIkGLKTtjiDSNaW1ZHmdjKmMINsjxunQ6g+jDVti/+5I7pupW2lzUraIpU2gBNj1rDFDiGJ+O2VM/jWSQN8GmLQD3+/C1b8D8z+Npz7K3AMwMErKulNLc1lS0UjCx5Yzvee/CTR4SilVJ92SEmbiCwA7gAuNMY0xxwvFBGnfXk0MA7Y3huBKqV6T2RT7fqWju2Rn5fVMWloNi6nA4dDyEtPOeT2yM3lDfz0lfW8+MlewEoWXfaatCK7PTI7rbXSNmN4Lh63g2H5aQzLTz+k5+zXKjfBw6fBRw9ZCduC+3XgiEpaZ00qZnxRFi2BEK+s3Ys3EEp0SEop1Wf1ZOT/k8CHwDEiUiYi3wR+D2QBb7Yb7T8fWCsinwHPAd82xlTHfWClVMKE7PbIlkCozcjtYCjMur31TCnNiR4ryEg55PbIFz7eE31ciF9py46ptKW6nHz75DHcOH/MIT1fv1a+Dv58DjTuhyuehHN+oQmbSmqThubwxvfnc/vZxxA2sLWiMdEhKaVUn9XtIBJjzJVxDi/u5NzngecPNyil1JEVDLcmavXeAIPsiYvbKptoCYSYGpu0ZR5apS0UNrz4iZ202UlimzVt2R3XtAH82xlxO6oHtl0fWhMinanW/msFmtSq/mPC4NZ9FieX5HRztlJKDUyHNYhEKZWcImvaoO0wkrVlkSEkrcM+8jMOLWlbsb2K/fVeoLWyF1tpy0t3c/MpY1gwecjBv4CBIuCFd+6HJedCarYmbKpfGlmQQYrLwSbds00ppTqlSZtSA1Ck8gVtx/6vLasjI8XJ6EEZ0WN56SnUNltJW7M/yFUPr2BzeUO3z/HSp3vI8rjISXPHVNpMtNImItyxYAITh8YdMKs2vga/nwnv/BwmXwY3LdeErY8QkQUisklEtorInZ2cc7mIrBeRdSLyF/vYdBH50D62VkQWHt3I+yaX08HYwkw27u/+74pSSg1UmrQp1Q/sr/Ny7n+/x66qph6dHxlEAm0rbZ/vqWNSSQ4OR+taqew0F/XeIMYYdh5o5oNtVXy0o/ulqrurW5gwOIv0FGfcNW2qC58/Z7VDenLh2pfg0ofBo8ltX2AP23oQOAeYCFwpIhPbnTMOuAuYZ4yZBPybfVMzcK19bAHwgIjE38NigJkwJItNmrQppVSnNGlTqh94d3MF6/fVs7m8Zwv5Q20qbVbSZoxha0VjdH1JRLbHTShsaPaHqLMTvLrm7tslm/1BMlJdOB0Sfb5QyOBy6J+dToVDsOIheOFGGD4XvvkGjD4l0VGptk4Athpjthtj/MBTwEXtzrkBeNAYUwNgjKmw/91sjNliX94LVAC65w3WuraKBh81hzipViml+jv99KRUP7B6Zw3QtoLWlUCbNW1We2Rlg49GX7BNayRAdpo13bHeG4gmbTXNbfd3u/wPH/LIBzvbHGvyh0hPceJ2OqLtkVpp60LZanj4VPj7nTDmNLjqGUjJ6P5+6mgrAXbHXC+zj8UaD4wXkfdFZIW9TU4bInICkIK1n+mAd8xgq5KsLZJKKRVft9MjlVJ935ovDy5pi620RRKxbZVWa+WYosw250ZG8te3BKNVuZqYSpsvGGLlzmrGFLVNMJp9QdJT2lXawmHcTk3a2vA3w9K7YfWfIGswfHUJTLxYx/n3XfH+hzHtrruw9ik9BSgF3hORycaYWgARGQI8BlxnjIn7H62I3AjcCDB8+PDeibwPi1T4N+2vZ+6YggRHo5RSfY8mbUolueomP9vthCt2z7WutB/5D7D9gNVaObqwbdKWY1fa6loC0fVvtTGVtv111oTIFn/bjXGbAyEyUpy4HBJ9Pq20tXNgCzxzHVSshzk3wyl36dq1vq8MGBZzvRTYG+ecFcaYALBDRDZhJXGrRCQbeBW42xizorMnMcYsAhYBzJw5s31S2O8UZaWSl+5m3V6dIKmUUvFoe6RSSe7jXTXRy7Ftj10JxBn5v72yCY/bwRB7/7SI7DRX9Ly6aNLWWmnbU9sCgDfQNmFs9oVIsyttkS0GrOmR+mcHsIaNLDrF2iz76udgwc81YUsOq4BxIjJKRFKAK4CX253zInAqgIgMwmqX3G6f/1fgUWPMs0cx5j5PRDhxzCDe3VxJONzvc1SllDpo+ulJqSS3OiZp8wdDXZzZKmRXvlJdjujI/+2VjYwalNlmciTEtEd641fa9tValTZvzHMHQmH8obBVadM1bW0FvPDKrfD8N6F4Mtz0How9I9FRqR4yxgSB7wBvABuAZ4wx60TkXhG50D7tDaBKRNYD/wBuN8ZUAZcD84HrReRT+2d6Al5Gn3TGxCIqGnys3VOX6FCUUqrP0fZIpZLcx7tqGFuUydaKxoOutBVkpLRW2g40Mbkkp8O50UEkLbGDSForbfvqrEpbbHtks305PdWFK2ZNWzAUJjV1AP/Zqd4Bz14H+z6DE78Hp98DTneio1IHyRjzGvBau2P3xFw2wK32T+w5jwOPH40Yk9GpxxThdAhvrS9n+jDdCUEppWJppU2pJGaM4fM9dZwwKh8Avz2IpKymmd3VzZ3eL5JE5WWkUO8N4AuG2F3dzJhBHacVZnns9khvsHXkf0sg2sK0ty5SaWttj2z2W9W79BSn1R5pV/ZCA7nStvFV+OPJULMTrngSzvqpJmxKxchNT2HWyDzeXF+e6FCUUqrP0aRNqSRW1xKgJRCKjumPTI+856V13PXC523OrW7ys3pndZvz8jNSqGsJ8GVVM2HTcQgJgNvpID3F2abSFjbQYLdV7rXXtPkCrZW2Jp9daYsMIgm1tke6BmLS9vGj8NTXoGC01Q454dxER6RUn3TGscVsKm/gy6rOv3RSSqmBSJM2pZLYPrvKNSQnDZdDoslYXUuABm/bvdT+uHwbVy/+CGittFntkcHouP/RhfH3Bcv2uK01bXaiBq0tkpE1bS2B2PZI67yMFFebNW0DstK28mF4+bsw9nT4+uuQNyLRESnVZ505sRiANzdotU0ppWJp0qZUEttfbyVMg3NScTsd0bVq/mAYf7v1bV9WNeMNhAmFTTSJirRHRsb9j4rTHgnW2P86u9JWnJ0KtCZte+si0yPjrGmzK22hcGylbQD92fng9/DabXDMuXDFX8CdluiIlOrTRhRkML44k7e0RVIppdoYQJ+elOrb/v7Fvmj7Yk9F9kgbnJOG2ynRfdr8wXCHjbYjo/kDodbbCjJS8AfDPLNqN2OLMsnyxF9jlZ3mor7FWtM2It9K7Grtal6kTTJ25H90TVuqPfJ/oFXaAl547Qew9EfWRtmXPwqu1ERHpVRSOHNiMSt3VrfZWkQppQa6HiVtIvInEakQkS9ijuWLyJsissX+N88+LiLyWxHZKiJrReS4IxW8Uv2FMYY7nv+cbz++JrpurCf213kRsTamTXE5ooNI/KGOSVtZTWvSFgobRCAnPQWAnVXN/Oi8Yzt9nmyPm8pGH/5gmBEF6YC1V1ukPXNojqdNe2RkTVt0c+1QZHPtcP9f07bnY3j4NFj5R5h9M1y6WAeOKHUQzji2mFDY8M6mSnzBUIdWb6WUGoh6WmlbAixod+xOYJkxZhywzL4OcA4wzv65EXjo8MNUqn/7srqZupYABxr9/NfSTT2+3/46L4MyrdbIFKeDQEylLRjTHtnsD1LdZH1rHQgZAiGD2+Eg254MuWDSYE49pqjT58lOc1NWYw0GiCRtNU2B6BCS0YWZ+IPh6ETJltiR/05HtD0yFOrHlbZwCJb+X/jf06G5Cq56Fs65H5wDeIsDpQ7BtNJcCrNS+ctHX3LWb5Zz9eKViQ5JKaUSrkdJmzFmOdC+b+si4BH78iPAxTHHHzWWFUCuiAzpjWCV6q/Wllmbyc4Znc9jK3axfm89AG9vLOfBf2zt9H77670MyfEA4HY5otU1XzAcrbpB64RHiFTawricwoxhecwfX8g9F0zsMr5sjyva/jgsPx2RtpW2yFo4n500NkXaI912pS12TZuzHyZtQb+1WfYHv4UZ18B3VsL4sxIdlVJJyeEQzji2iJU7q9lV1cznZbVt1swqpdRAdDhr2oqNMfsA7H8jX9OXALtjziuzjymVUH/65w5eXbsv0WHE9fmeOlJcDn552TSMgdW7rO9InllVxi/f2MTyzZVx77e/zktxtp20cQU43QAAIABJREFUtRlEEmrTHhlpjbRuCxOwK17DC9J59BsnMDS36wEZkQ22wdpLKdvjprYlwL7aFhzSWn2LtEi2bq5t7dMW6s9r2nyN8ORCWPdXOPOncOFvwdNxk3KlVM9dd+JIzp0ymLvOmUDYwJbyxkSHpJRSCXUkBpHE+0RmOpwkcqOIrBaR1ZWV8T+QKtWbHv9oFy98XJboMOJaW1bLxCHZDLarZrXN1hqO2harpfGel76I+01zm0qbs92atpjNrve0q7QFw2Hczp7/558dM6AkJ81NXrqbmuYAZbUtFGV5yEy1WgAjMTb5grgcQorT0WYrgn43PbJ+Lzx6EWx/By56EOZ9L9ERKdUvTBiczf987XjOmjQYgA37re6D/XVejOnwkUIppfq9w/n0VB5pe7T/rbCPlwHDYs4rBfa2v7MxZpExZqYxZmZhYeFhhKFUzwRDhgZfsPsTj5K1ZbVcs/gj9tS28MWeeqaU5OB2OshMdbUmbc3WiP2dVc08+uFOANbsquH6P6+kttlvj+C3kraU9tMjw60fbGIrbYGQOeiKV05a26QtNz2F2mY/K3dUM2loNh63E2hbaUtLcSIiuJz9sNIW9ME798PvjofyL+Dyx2DG1YmOSql+Z3h+OmluJxv3NbBubx1z71/GO510HiilVH92OEnby8B19uXrgJdijl9rT5GcA9RF2iiVSqRAKEyjt28kbcFQmB88t5b3thzg5sfX0OgLMqXUaqnLSXNHK2x1LQHmjytkTGEGa3bVAPDupgre2VTJ8x/vAWhTaQuEwgRDYcLGer2Rb6T31LSttFmDSHqePGWntQ7TsJI2N59+Wfv/2Tvv8LjKM33f3/QZdcmS5S5b7tim2KYZCMQ4dEgCSSCNNJJset1fQjbJbjZtUzdtSYCQDoFQQseh2xiDccG9y5Itq9eRps+c7/fHKXNGGskqIxf5u6/Ll0Yzp3wztmfOM8/7Pi/1nREuXzjREm1RS7QlyfPo+7gc6eHaiZR26ve0Ne+Eu1bCSz+AOW+DT78OC6490atSKMYlTodgbmUBe5qCPLOjCSnh9ZrhjUZRKBSK8cCQYs2EEPcBlwIThBD1wLeBHwIPCCE+ChwG3mVs/hRwNXAACAMfzvGaFYoRkUhJek8Sp+2Pr9ayp6mHi+dMYO3+NgCWGKKtOOCm2+a0FQfcTCsNWCWO9cbPv71WB0Cl6bQZQSRmiaSUurPlcoqM8si4EfnvHIZ4spdHFvhclAQ8lmu5cn4Fuxr10iUzrCQUTxHw6kKub0/bKRv5H+uBl/8HXrsD/CVwy99h3lUnelUKxbhn/sQC/rWryUrA3VbfdYJXpFAoFMefIYk2KeUtAzy0Msu2Evj0aBalUIwFSU0jFDvxvRCxZIr/fW4/l80r57cfWMpVv1hLY1eU2eX5gC7auiIJookUkUSK4oCHKcV+th7RL1RM16ymLQRg9cG5nQ5C8ZRVIgm6UHU59X0mFflo7I6SMAZvu4fRW2YGkeR5nLidDooD+u9nTiumotDHIWMtptMWiacIeHTRZva0SSlJahLnqdjT1rYf7rsF2g/AOR+Ald+GvAknelUKxWnB/EkF3L/xCJ3hBH63k+313WiaxHGqfgGkUCgUI+AUvHpSKAYnlkxx4Q+e57Gtma2UiaR2UvS09UST9MaSvHV+BV6Xk7s+uIz/e/85uIxgkGK/3i8WNIZsF/ndTCnx0xlOEI4nqe+MkGcIIsgUbYmkliHa4in99+aeKFVleix/UpMkU8OL3jedNrO3rcQYyr1qgR4a27c8MhRLEjDLI42eNrPF7pRz2vat1odlRzrh1sfh+l8pwaZQHEfmVxZatz+0ooqeWJLa9tAJXJFCoVAcf5RoU4w7WoIxGrqjrD/YlnF/QpPEkxqx5Imd92MmKZrpjdXl+RmDrYsCbrojCboM0VYccDPFiOSvaw/TFIzy9rOn4HQICn0uSxx5XLqjFbOJtmRKo7E7gpRQZcxSi6e0YTteZk+b6bhVFHgBWLVQT3ZLizb93OF4yhKWTqOnzXzep0wQiabBmp/Ave+B0pnw8Zdg5sUnelUKxWnH/MoCAGaV53HDWZOB9GxLhUKhOF0YUnmkQnEq0dITA2Bfn7k+pmgIxVJ4Xc5++x0vEkndchoocr/Y76YrnKDT6N8o9nvwe/RtN9V1ktIki6YUcV5biGA0Ye1nBpHYh2onUtIagF1lzFJLJM3I/6GLpwLDaTNF2w1nTaFqQh7zjIspf7/0yCQBj34+01kzX/9TwmkLNsI/P6lH+S9+F1z3SzCej0KhOL6U5Hk4t6qUyxdWMLs8H7/bydb6Lt5+thoBq1AoTh+UaFOMO1p7dJGyr7kHKSVC6OV55mifUCxJaZ7nhK3PFFVu1wCiLeAmqUkauiPW7+WGs7XhkJ6aNqXYz8/fcxaxRFqguZ0O4n3KIxMpjYgx6NrsQxtJ5L/TISjwuqzySL/HyfmzyqzHfW79uURtkf8BTzqIRH/sFHHamnfBX94BsaAu1s75IIiTfM0KxTjngU9eYN0+Y3KhctoUCsVphyqPVIw7Wg2nrSeatFy3hM196jnBsf+mqPIM4HQV+3VBWdsWBvQ+svJ8Lx6nIy3aSvxMLPQxvSzt/ujDtWW/njazXDLPGICtR/4PL4jEPKdZptkXb5aeNvN8pqNnlqWe1E5b3Xr4g5EI+bHnYOmtSrApFCcZS6YWs+NoN3uMgdsKhUJxOqBEm2LcYQo10N02yBRtJzr2v29PW1+KDEfscIcu2ooDbhwOwaRiH01B3UXMJp68rv7lkcmUtH7PN0RUPKUNO4gE4G8fO49/v3Je1sf8/ea06cO1Aat3zhSPzgGe9wlFSnj9d/CnayFQBh9dDRPPONGrUigUWXjXsqkU+Fxc96tXuG/D4SHv1xGKq3EBCoXilOUkvHpSKEZHSzCG1yg93G/0tSVS6aj/3lgi637Hi2OJtmKjBLG2PYTTISyxZQq1CfkeK/jDjtupB5H0LY80f8+3OW3JYZZHApTle63Qk2zndgi9BDKe1I+fZ4v8B6xSzpPOaQu1wd/fC0//O8xeBbe9ACVVJ3pVCoViABZMKmT1Fy7h7Gkl/OCp3RnveYPx6xcO8O7frc/4Ek+hUChOFZRoU4w7WntjVJfnUxxws79Fd9qSGU7biU2PjB9LtBlx+nXtYYr9boRRnmeKtoFKFK0gkiyR/2Arj7SCSHL3318Igc/tJJpIEY7rTqYp8KyeNqM88qTqadv3L/i/C+DAc/C278LN94K/+ESvSqFQHIOyfC+fvHQWwWiSdQfajr0DeuVFNKFR26bGBSgUilMPJdoUJzUv7m3hiFEmOFRaeqJUFHqZW1GQdto0m9M2zJ62NftaOdw+vDUMhun6eVwD9LQZ5ZEdobhVKgkwtSSQ8bMvumiTGSMNErYRB2mnTZ/Tlmvx5Hc7iSRShIzgEzOIxOppO5mctngYnvgS3PsuyCuH216ECz8Lp+Lgb4XiNOWi2eUU+Fw8ub2RWDLFY1sbrOClbBxs1T8P9hpl8wqFQnEqoa5QFCc1n7t3C3euqRnWPq09MSoKvMyZmG8lSCaSdqdteOWRn/v7Fu5Zd2hY+wyGuZYBe9r8aaFWbLs9pcSf8bMvHqMkNGRzEpOa7Oe0mXPahhP5PxR0p00jYjptXtNpM3vaThKn7ehm+N0lsPH3cMFn9HLIykUndk2KUwohxJVCiL1CiANCiK8NsM27hRC7hBA7hRD32u6/VQix3/hz6/Fb9fjD43KwauFE/rWzia/+Yxufu28Ln/jrpqyzOEOxpDX+pO84GIVCoTgVUKJNcVITiic52hUZ8vYpTdLWG6eiwMecinyC0SStPTGSmk20DcNpk1ISjCSsb28buiL8eX3tkPfPhtlP4Rkg8t/ndloR+mapJAylPFIXQ/aglczySKd1/mRKw5VjV8nndhBNpizR2LenLWo5bSfobUdLwZofw+9XQTwEH3wUrvgeuH0nZj2KUxIhhBP4DXAVsBC4RQixsM82c4CvAyuklGcAXzDuLwW+DZwHnAt8WwhRchyXP+64dskkgtEkj21t4LJ55azZ18qXH9jab7tDtpLIfU3KaVMoFKceSrQpTlqSKQ1N6kJpqHSE4qQ0SXmB1yojbApGiSftQSRD72mLJvQ1mH1oT2xr4FuP7swYaj1cjtXTBunYf7vTtnByIUtnlHBhdVnWfTzG8eyiLZHU0ySF0B93OYQVRJLrMkWf20k0niJkOG1meqSrT+T/CXHaOmvhD1fDC9+FhTfAp16FWZce/3UoxgPnAgeklDVSyjjwd+CGPtvcBvxGStkJIKVsMe6/AnhWStlhPPYscOVxWve45KLZ5Uwr9fOeZdO450PL+fRl1TyxrbHfl31maWR1eZ6VKqxQKBSnEkq0KU5azIh4s6RlKJgz2ioKvHgNtypuBG+YDKc80hQgpltlukX2odbDxeppG0y0Gb1s9p62Ir+bh/7tQuZMLMi6j9sqj7SJNmNum8fpQAhh9b2NJPL/WPjcTqLJFGHLadPLI09oemS0G577T/jN+dCyG955N9x0D/iVuaEYMVOAI7bf64377MwF5goh1gkhXhNCXDmMfRXDwONy8OKXL+V/blqCEIKrF08C4A1jpqXJwZZenA7BqoWV1LaHrPEkCoVCcaqgRJvipMUUbd2RRIYQGYyWHl3glRd4LVEUT2ojntNmntdciynesvVMDJVjRf5Duq/NdNyGgnm8TNGmD9c2SzHdTmFF8jtzXKboN3rawsbFkFmO2benLddicUB6muHuy+GV/4UF18G/rYMl7zo+51aMZ7L9A5Z9fncBc4BLgVuAu4UQxUPcVz+JEB8XQmwUQmxsbW0dxXLHPy7be+n8ykIKvC421OqibU9TkGgixcHWENNLAyyaUogm086bQqFQnCoo0aY4abELo8buoZVItlhOm89ynmIpLWNOW88wetpMgWeWNJo/Y0OcC5SNtGgbWLyYTluxzWk7FunySFt6pCHazLl1HmMAtx75n2unzUEkniIcy4z8t5y25HHsaetphj9fD931cOvjcONdUDxt7M+rOB2oB+z/mKYCDVm2eVRKmZBSHgL2oou4oewLgJTyTinlMinlsvLy8pwtfrzjdAiWVZWw4VAHRzrCXPPLV/jGIzs42NpLdXke84xKBVUiqVAoTjVGfPUkhJgnhHjT9icohPiCEOI/hRBHbfdfncsFK04f7PPGGrqGViJplkf2ddqShmjzuR3DctrCRgBJoq/TNorySPMY7gGCSMDW0zYM0ZbdadPLI70up7WNHkSS+8h/r1Ee2TfyP93Tpj/vMe9pq3tVT4fsrIP3PgAzLx7b8ylON94A5gghZgohPMDNwGN9tvkncBmAEGICerlkDbAaeJsQosQIIHmbcZ8ih5w7s4wDLb385F97SWmShzbXs7+ll+ryfKom5OF2CpUgqVAoTjlcI91RSrkXOAusNK2jwCPAh4GfSyl/kpMVKk5b7G7WUJ221p4YBV4Xfo/TcpcSqXR5ZLHfM+RSS+jvtMVyUh45jJ42/3BEmy6GzD48/Vx6EEm6PNLoacvxcG3QyyNjCY3mYBSPy0GhT1+7NVw7McblkZEueOkHsOEuKKmC9z+kovwVOUdKmRRCfAZdbDmBe6SUO4UQ3wE2SikfIy3OdgEp4KtSynYAIcR/ows/gO9IKTv6n0UxGs6dWQrAo2828LaFE9l8uJO23jjV5fm4nQ6qy/PZXNd5glepUCgUwyNXV20rgYNSyrocHU+hyHCzhuO0lRd6gXSkvr2nrSTPkxH5/7fX6/jS/W8OeDxT4MX79bTlojxykJ42qzxy6D1t5vO1l38mUhrxZMoSiG6n0Oe0pcYiPdJBJJGiti3EjNIADuP4LqunbYycNk2DLX+FXy2FDXfC0g/Bx19Sgk0xZkgpn5JSzpVSVkspv2fc9y1DsCF1viSlXCilXCyl/Ltt33uklLONP384Uc9hPLN4SpE1NuVzK+fw1SvmAXoCL8A1iyfx+qEO6tpDAx7Dzm9ePMB7frd+0MHdCoVCMdbkSrTdDNxn+/0zQohtQoh71AwaxUixu1lDjf1v7YlRnq+LNndGEInubpUE3PTYnLaNtZ2s2d824PHMJERLtOWgpy2e1HCIwcVLqSHWSocj2mzlkeaMtERK9gkicVhBJDkXbS4n0USKuvYwM8ryrPudVnqk4bTl8rzNu+APV8Kjn4ayal2sXfsz8BXm7hwKheKUwuNy8Ja55Vw2r5xFU4p497JpvPiVS1k0pQiAdy2bhkPAAxuPHONIOi/uaeH1Qx3c/sh2pMyaG6NQKBRjzqhFm1HTfz3wD+OuO4Bq9NLJRuCnA+ynkrEUg2IKIyGGHvvfGY5TYggdy2lLpSP/SwJ6eaT5wRtLpogPUupolkea7pi5rSlAUpoc9od4InXs0sRrz5zMz99zJtPLAkM+rj3yP+B1WeeK9wkiSZcp5rg80mOIto4QVbZ1u8eipy0Rhef/G353MbTth7ffAR9ZDZPOHP2xFQrFKc8d71vK3bcuB0AIwcwJ6S+SKot8XDavgn9srCeZOvYXcAdbeykJuHlky9EhCz2FQqHINbm4arsK2CylbAaQUjZLKVNSSg24C30QaT9UMpbiWJju1uQiPw1D7GkLRhNWH5i9PNI8VnHAjSYhkjDFlzaoazZw5L/+860/fYm71tYM73mltEH72QDyvS7ecfbUYR3XbRuu7Xc7cYi0aLM7bWaJT67LFH1uJ5rUZ9nNmNDfabPE4mjTIztq4LcrYO1PYPG74DMb4az36upeoVAoAIdDDPoed/O502npifHi3sG/NG7vjdEZTvDpy2ZTXZ7HMzuacr1UhUKhGBK5EG23YCuNFEJMsj32DmBHDs6hyAEdofgpVdphlkdWTQjQ2BUd0tqDkSSFft1lstIjU3o5IEBpnu7CmX1t0WSKeEob8NhmEmK2yH9Nk9S1h3l489FhPa9EShs0OXKkpINIUnhcDr0Usl8QibAEa+4j/53WbbvTltOetrb98IdrINwBH/gnvOO3kFc28uMpFIrTksvmlVNR4OX+Nw4Put3BVr3vbXZFPkumFrOnafBRAWaCsUKhUOSaUV05CiECwCrgYdvdPxJCbBdCbEOPPP7iaM6hyA1N3VHO//7zvLTv1ClFNS/yq8ryiCRSdEcSg24fT2pEEikrtTDbcG0z2MPsa4slNKTEEnV9GTiIJEXUEJV7mno40hHut29DVyRr6U0iKY/ptI0E85gpTT++2+kgkdQj/9NBJGmnLdfz0szGf9D/zkz6O20jEG1aSk+FvGslaAn40BNQfdnoFqxQKE5bXE4H71o2lRf2tNA0SPm9OYS7ujyf+ZUFNHZH6QrHs267r7mHc7//HG/UqkBQhUKRe0Z11SalDEspy6SU3bb7PmCkZS2RUl4vpWwc/TIVo2V3Y5B4Shv0w+lkw0yPNHsRjh4jjKQnqou6QqM80uEQuByiXxAJpJ222DHSIM34/HRPW3pOW9SWbvn87uaM/RIpjVU/e5lfvnCg3zF1py33pXz2PjndaRMkNS0jiMTjdFhOW66j933WLDjBpCKfbV2j7Gk7uhnuXglPfQWmnA0ffRYmnpGbRSsUitOWdy+bhibhwU0D96kdaOnF53YwpdjP/El6wNHuxh5e2d/GDb9ZR3tv2lnbeqQLKfXPW4VCocg1uf+6X3FSYn5baLodJyNbj3SRsjleZnnktFK91K4lOHjZSdAQYmZ5JOjiRR+unQ4iAXuvWmY6ZF/6Om12kRexvZbP7W7J2C8c14dMP7jxCFofFy8+hCCSkeBx9RVtDlsQSXq4dniMnDa/kVg5rSSQEXIyojlt8TBs+wf85Z1w11sh2AA3/l4viSydmdN1KxSK05MZZXmsmF3G3984QiKlUd8Z5tpfreVn/9prbXOwtZdZE/JxOAQLJhUAsKcpyH1vHGbrkS6+/9Qea9sDxudstsoLhUKhGC1KtJ0m1LTpdfl2d+hkoq49xA2/WZfhWJkCqczoQ4scQ3AGjfJJszwSdPGSMVzbcNp6BggY6UvIiPxPahJNk7aetpQlQqYU+3mtpp1gNF2+aZYgNnRHee1Qe8YxE0MIIhkJdiHoNXvakn0i/1328sjcz2kDmNEn8XJYPW2ddfDEl+Anc+Hhj0HbPrjkq/DpDbD4JhU2olAocsoHzq+ivjPCqp+9zE13rGfH0SBPbEsXCB1o6aW6Ih+A8nwvZXkettd3s2ZvKwVeFw9trmf9Qf09/mCLKdqGFpylUCgUw0GJttOEGuMbwNgg8fYnkmbDRWuxNXHHkplC61iDTYN9yiNBLweMp+zlkZlBJGYJ5kCvi1keCbpDZnfczPWsWjiRpCZ583CXta1dYPYNKkmk5Ng4bfbySKdeHmkO1/bagkhM4TlW5ZH2GW1gm9NmvHZZHb5IJzz5FfjVObDlL7DgOrj1Cfj8NnjrN8BfnNO1KhQKBcCViyq550PLjPRbyY3nTKWmLURbb4xIPMXRrgizy3XRJoRg/qQCntzeSE8syffeuZhppX5++PRuAPaboq1TOW0KhSL3uI69iWI8UNN6cjttZmO33a0yL/JN5+zYTpsusIpsos3tdBAzgkhcDkG+T/8nb4qxoZZHQqZoiyc1y2kznaVOW3O6Kegm5Ht4ensj/33DIqt8UJ/TNgY9bbY+ObM8MqllpkfahV2u57T5jOdX1cdpS/e0ZRk1oGnw5t/guW/rwm3ph+HiL0PRlJyuTaFQKAbirfMnctm8CpKaZFt9Fw9trmdjbSfTSv1ICdUV6S+i5lcWsu5AOx6Xg8sXVFDbFuJnz+6jqTtqlUWaP7fV6yX/Z08vOSHPS6FQjC+U03Ya0BNNWA7WydTTtqcpyBojzbLLKG00hRfoF/kel8MSO9nWHo4n+cO6Q8STmpUuaS+P9Jo9bZrubvmNWHpTVB0ziCSWPmc8qfUpj9Rvm6EbnSGbaEvoz+O6MycTiqfYWt+VcZyxcNr6B5Hozz3WJz3SJNflkdNKAlQW+lg+szTj/nRPm+m0Gedt2AK/XwWPfQbK5sDHX4Zrf6YEm0KhOO4IIXA7HSyaUoTH5WBjbQc7j+qBItWG0wYwv1Lva1tRXUbA42LFbH3kyL0bDqNJOHNqEcFoku5Igq8/vJ0vPbD1+D8ZhUIxLlFO22nAIaOfDQYWJyeCO146yIZDHaz/+kq6w7rg6rE7bQkNr8thzf/KVh75k9X7uGfdIarL823lkf2DSOJJDZdTWMeKJjLFWjxLND/ojpzXpbt19iHdsUQ6iGRioSHawvaeNn27eRP1D3h7amcipZHnzf1/PbsI8zgdev9aIoWU2Mojx060lRd4ee32lVnWZfS0mUEk8S549nuw8Q+QVw5v/y2cebPqV1MoFCccr8vJWVOL2VDbwUv7Wpldkc9c430cYPHUIgBWLawEYMnUYgIeJ/dt0Oe9XTqvgq313ext6mF3YxBN6u//lbZEXYVCoRgJymk7DTBLI4VIXzifDIRiSdp79YHfXRGzPDKzHNHrcuI2+rP6lkfubOjmj68eAqApGCUYSeByCMtNg3QQSVLT3SanQ1ix98mUZqVVxgYoGw3FklYfXIZos5VHFvhcFPhcGXPkwkb5ZZUxrqApaBdtY9PTJoRIl0G6HHicgl7DKUwHkaSFUa572gbCdNriySQ3O1/A83/LYdOf4LxPwmc3wlm3KMGmUChOGpZVlbCtvpsDLb188fK5GSXd8ysLeeATF/Ce5dMA/Yuwc2eW0toTwyHgkrkTAHhyWwNmcPBrNe39zqFQKBTDRYm204Ca1l4cAqaXBqyB0CcDkUSKeEqjJ5akaxCnDcDndvYTbf/52E5rWHZLMEowmqDQ70bYBIDbDCJJSkuk+NwOoolUhuuYzWmLJVMkUpISI70yZpRZmo+Z6/G6nJQEPJk9bQmzp81Lgc+V4bTp5ZFjI1LMMkiPy4HL4SBs9ORl7WnLceR/PzQNtv0D910Xsdrz7zzm+Co/dN8N5fPgE2vgqh+Cr2hs16BQKBTDZFmV3oM2v7KAqxZV9nv83JmlGUJuRbUu1KaXBphdrrtyZgJlnsc5oGjb2dDNJT96kdU7m3K6foVCMT5Rou004GBbiGmlAQp8rgEdpROBOS+sozdu62mzB5Gk8Box8n63M6OnLZnSeKO2k/edN50iv5vmYIxgJEmhL7Ps0GP0dSU0zRIpfo+TSLyPaMtSNho2XCprIHfM3m+nWa6l3+OkJODOKI+M2h6rLPT1K48cC6cN0qEfHpdeHhnqI9oyyiPHymmTEvY+Db+9CB7+GAJBnZxIkDy+lPw04sNPQ+WisTm3QqFQjJLlVaUsmVrEN69diGMIZeQXVOt9bbMr8ikKuCnwuWgPxZldkc+FsyewPoto29MU5P13v87hjjBP2kYMKBQKxUConrbTgJrWELMm5NETTZ5cTpsh2tpDcVtPW6YwMp0hU2hZ+xqiqMjvZmKhl+ZglHhKy0iOBF2shMNJkilpCRef20k0mcqI+c8W+W+KNGtMgF202XrafG4nRQGPlYAJaUEacDupLPLRaCuPjI/RnDZIizKvUy+PNOfRZQ8iyeEawh1weD3UroPdj0P3YSidpQ/EPuOdfOabq41yVwc/U6WQCoXiJKbA5+axz1w05O0XTiqkqizA8io9hGlaSYBdjUHOmV7MvMpCnt3VTENXhMnFfkD/4u6Tf9mEx+Vg2YwSNtV1Zj3uC3uamVNRwLTSQNbHFQrF6YUSbacBLcEoZ08vJt4eOqki/03R0xGK23raMiP/vUZ/mr9PeaQp4PweJxMLfTT3xHCKzBltYASRpKQV+W8dK57KcB2zOW3mWICSPMNpi2YmW5phIz6Xg5KAm1pb4Eukj9O2v7nNeixhi+DPNW5beaTbmXbazNfRXpaZE6ettwVe+z947Q5IRsHpgVmX6bPVFt0ITv21czrwUFU8AAAgAElEQVQEpHIffqJQKBQnGodD8MKXL7VcuWmlfkO0lVjBJesPtnPj0qkA/GNjPbXtYX5/6zLq2sN854ld/cJK9jQF+cgfN+JyCN69fBrfvm4hXpez/8kVCsVpgxJt4xw95CNBScBNc7czIyzjRGO6Ue29MaunzR75bx8Krfe0af329budVBT4ONDSRp7XxaQif8Y59PTIVEb4h9kfd6zySDPuv9Ry2jIFZTSZwu0UuJyOfj1t0XgKIfTUxklFPlp6oiRTGi6nY8yCSMzna/50OR1WI7y9181kRAIqEYWDz0PNS3BoLbTuBgQsebc+Y23y2eDun5LmcgpI9JnRplAoFOMEexnltBLdGVs6o4Tq8nymFPv5/SuHePvZU0ikNH75/H7OmV7MW+dXsK2+G4DNhzu5evEk6xjP724B4MZzpnLv64cpCbj56hXzj+MzUigUJxtKtI1zemNJUpqk2O/RywJPIqctaiuPNEVbJJGyer5iSY18Ixrf73Za25vbAQQ8TiYWemnpiVGS0jLi/sHoaUtpGQOtzf64zPLIbKJNF5DFlmjL3D4ST1kjBIr8bnqiSUuYheMp/G4nQggmFvnQJLT1xqks8pEYozlt5vM1f9pdteyR/0NcQ6wH9v8L9j8He56EWDe4AzD9fF2szbsaKga/mDAFYq4HeisUCsXJxjVLJhGKJ6kuz8fhEHztqvl89r4t3Pt6Hbsae2gKRvnfm89CCMHCyYX43A421fUVbc0smVrE/9y0BE1K7njpIJcvmKgGdSsUpzFKtI1zTDFUFHDjdTlGPVz7u0/swuEQ3H71glEdR0pJ2FhLSzBKbyxJaZ6HjlCcnqh+O5bQKMszyiM9TlqNAeGQdtp8br08MqVJ2nrjGYO1IR1EktQ0m9PmoK03mSFgsztt2csjPS4HMaMnzhRtZlhJdyRBWb6XSCJljR4wh283dkeoLPIRT2kZ0fu5xDyux+XM6JsbURBJtBte/RVsuFO/7SuG+VfrQm3GReDyDHldTkMgKqdNoVCMd86eXpIhrq5dMok/r6/lm4/uBOC2i2dy/iw9vMTtdLBkajGb6jp5eHM9e5t7+OhFM9lypIsvrJwLwDevW8i6A21845EdPPX5i4/781EoFCcHSrSdJDy+tYGfP7ePf33hkpy6EWY5ZLHfjdftHPVw7TdqO0Y8U6s3luSKn6/hp+8+k7OnF1sz0mqMXrBppQFDtCV00WYrjxyopy3gcVnDrWGAnrZkZuS/32OWR6aPly3yP2Sco7hPeWShkcIZiaeFmTkWoDNsiLZ4Cr9Hf8xcX7MRRpI4DkEkZk+bSVq02XraBhJQmgY7H4bVt+s9awuuhfM/BdPOA8fIeiosp02JNoVCcZohhOC/rl/Elx54k09dNpvrz5yc8fjSGSXc8dJB3jzSBcDafW1ICSsXVABQ6HPz4RUz+d5Tu9WgboXiNGbUV45CiFohxHYhxJtCiI3GfaVCiGeFEPuNn8rPz0IsmbKEy3O7m6lpDWUkFOYC02krDnis+WSjIRRP0RsdWV9cQ1eEo10RdjcGicbTIskc/j2tRO9HM/vazLRBMPrQBimPNOkX+e/Se8gSGU5b/yCSwcojS/ukRxb43MZwbc0SbaawMxMkM502/Xk1dkdJaRJNMoaR/9lFmzfLnLZ+a0hEYev98NsV8NBHoWAS3PYCvOevMOPCEQs2SLt6ymlTKBSnIwsnF/LMFy7pJ9gALp1bjhDwqUured9509nVGGRioZczJhda21w4W3fm1te00RKMcvGPXmDDoY7jtn6FQnHiyZXTdpmUss32+9eA56WUPxRCfM34/f/l6FzjAiklq362hhvPmcrnL5/DdqMZuTeWtARALjBTGYsDbrwu56jntEXiKZLayI5hCsjeaJJwIi1Oj3ZFAH0wKaQTJGMJLT2nzZMpOMNGsqPP7aQ0L/169XXa3GZ5pC38I93TZhdt6WNLKemOJKz0SPP45jiCAp+Lxu4IkUQKn7G+YuO8nbbePNNpKwm48bgcNAWjJAxH73j3tGUrj9QTHRNw8AW9V233YxDphAnz4B13wuKbRiXU7CinTaFQKLJz3qwydv3Xlfg9ThIpfZzMGZOLELaqlgWVhRQH3Lx6oJ3mYIwjHRGe2dHEuTNLT+DKFQrF8WSsyiNvAC41bv8JeIkTLNqSKY2OcJyKgpOjrKAznOBwR5jVO5v48EVVVolgOD46J6wvltPmd+Nz66EcmiaHNDA0G+F4kkRKjnAtuoDsjSct18wsX4S0aOsxRVtSsyKOBy6PdFJeYHPaskb+a8ST6ch/X5YgEntP21Pbm/jC/Vu4sHoCToewwlBCsbRoiyU1Q7SZwizTaQvbSieFENaA7bgl2saop804rrdveaQ5p80Qb3lEKNz0a9j6BwgeBU8BzL0CzvkAVF0CuZzhRtphU06bYjwghLgS+AXgBO6WUv6wz+MfAn4MHDXu+rWU8m7jsR8B16BXujwLfF5KObI3VcW4wfySz+108LN3n9XvcYdDcMGsMl492M7Wer2MckNt/6HdCoVi/JIL0SaBfwkhJPA7KeWdwEQpZSOAlLJRCFGRg/OMike2HOXbj+1k03+sst4cx4JkSuNwR5hZ5fmDblfbrou0XY1B1u5Lm5S5Lo80e9oK/W5LYMSS2ohfg3Bcd6hGIvy6IjanzRBdU4v9GT1tkC6PzNbTJqVECJFRHul2OpiQ78kaRGLuH04kLcFiHmugIJKjXWESKcnL+1op8Lksl8oqj/S6kVJ33ioMwVhshJWYIjmaSGU4gJWFPhq7oySM8xyvOW0mHqeAA88x+82n+K6rlqucG8hf2wMz3wJX/xhmXw4u70CHHTVmUmVOB3orFCcAIYQT+A2wCqgH3hBCPCal3NVn0/ullJ/ps++FwApgiXHXK8Bb0L/YVCgG5cLqMp7e0QTA1BI/uxqC9EQTFPT53FMoFOOTXFxBrZBSngNcBXxaCHHJUHYSQnxcCLFRCLGxtbU1B8sYnKNdEcLx1JjPKXtmZxNv/enLbDncOeh2de3pQcx3rjlo3Q7lvKctjt/txOd2WgJmpH1tKU1aJYVm6eBw6DbLI2NJS3RNKUnPVbOXR0qpn8sUNz6PEynTvWf29EjAclCLskT+A4RjKdyOdBCJJtPBIj63I6NU0j5EO9+bFm328kiAYCRhuWkFXhdOh7BmtYXjKQI2YVxZ5KM5GLVcyrGe0+YlQWmikamilfc7n2XifW+Dv97IpD1/4Rrn6+zQZhL64Gq49TGYf82YCjZQPW2KccW5wAEpZY2UMg78Hb26ZChIwAd4AC/gBprHZJWKcccF1RMA/XPt9qsXoEnYVJe+1kgalTQKhWJ8MuorRyllg/GzBXgE/QOtWQgxCcD42ZJlvzullMuklMvKy8tHu4xjYl6Ij0RsDIfGLj0h8M41NYNuV9sWRgjI8zjZWt9tBTKGYrkvjyw24ujtTttIsJcnjsQRNPvreqPp8sipxhBSIfRofCEgGE2S1CRSkuG0QVpwRhMpHCL9uBlG0i/y33g8FE9mBJGAzYX0uTOctt5Yinyvi4tmT2BSkQ+XQyBEZhCJub/Z0yaEoNjvTve02Wa4metrHuueNk2jQmvjI86nOfPBFXzg9et4xft5vuv+Aw6Zgut/zY4P7uTs2J3cmvgajqnLc7+GATBLU8eqLFShOI5MAY7Yfq837uvLjUKIbUKIB4UQ0wCklOuBF4FG489qKeXubCc53l9sKk5+qsvzmFri54pFlVw6rxyXQ+iJzgZX/mItv37xwAlcoUKhGEtGVR4phMgDHFLKHuP224DvAI8BtwI/NH4+OtqFjhZTrOXayeqLKUye2dlEbVuIqgl5Wberaw8xucjP/MoCnt/TwsJJhexsCObeaYskKPKbom10TlvYJnhHsk6zdLAnZiuPNJy2Qp8bl9NBvsdFTzRhCUt7TxvowrEYMoZXQzpWP1sQCUA0oVmjFMzXwVxPgc/VR7QlKPC5uPvWZSQ1vRzT43Rk9LTp2yUzykyLA266jb//qC09EvTh29GEZv07zKl4SURg/a9h3S/5ViwIbgiVXcSGwrfy5LajbNVm8dDHP4nT48LVELR2O56ul+ppU4wjsv0j7mtvPA7cJ6WMCSE+id7b/VYhxGxgATDV2O5ZIcQlUso1/Q6otxrcCbBs2TJlnygQQvDwpy4kz+Mi4HGxaEqRlSDZGYpzoKWXjXWDV/koFIpTl9F+3T8ReEUIsRXYADwppXwGXaytEkLsR6/7/+Egxzgu9BoOVq6drL50hfWSObfDwd2vDOy21baHqZoQ4MLZermDOWgz105gt81pMwVQNDlC0WZ77XqiI3HadJEUiiWJGOmRpmgz11jodxOMJIkZwtJMjzRdK9OhC8dT+D3p7xwWTy2iqixgOW8m9t4xjzmnzThWVySB0yEIeFwZoSS9sSR5Xhc+t9MKIfG4HDanLX1eu5tWEvDQGUpY67OXR5pisr03bqwlB05bqA3W/hR+tRRe+C5UXcyjU7/CDbHv0PT2+6mtuol7UyvZKWfiMf7uPbah3sczyVH1tCnGEfXANNvvU4EG+wZSynYpZcz49S5gqXH7HcBrUspeKWUv8DRw/hivVzGOqCjwkWd8Lp03s5StR7qJJlLUtPUCUNPaeyKXp1AoxpBRXUEZNf1nGn/OkFJ+z7i/XUq5Uko5x/h5woeJmLPFwmNcHtkVSTCpyMc1Sybx+NbGAevL69pDzCjLY9WCiZTlebhqUaW+zpw7bXGK/XoghukwjTT2355sOaLySDM9MpYkYsxps0SbIWoKfC6CGU5bpmgzw0OiiUxR9L7zZvDSVy/LiEiGTNHmcmaWWnaHE/hcDrxGwqRJTzRpiTXrOE6H1Y9mL8G0i7bigIfOcBwpZcacNvN5AbT1xvqta9g0boVHPgk/WwDPfwfKquGDj8It9/LmxHeyVc42Iv9NoSSs0BjzPodgxAmiI0H1tCnGEW8Ac4QQM4UQHuBm9OoSC7M9wOB6wCyBPAy8RQjhEkK40UNIspZHKhTH4uzpJcRTGrsbgxxs0fvkj3ZFMmaaKhSK8cNYRf6fdJgOW65FUV+6wwmKAm4uqC7jkS1HOdjay5yJBf226QwnmFEaYHpZgE3fXIWUEofIdLNyQUZPmyuzL2y4RGyz1XpH4rTZ57QZ4nma0dNWZETmF/rcGeWRprgxyxDNvrpwPJkhigbC7miZwsHnSfe0ed3OjLEDoDuBBVmGdJvYH/O7M8sjdxxNr93uBJpCryOkC9dh97R1H4V9T8POf0LtWvDkwzm3wvKPQcX8fs/X63KkZ7bZ1m4JuTEKQhkIU6y5VE+b4hRHSpkUQnwGWI0e+X+PlHKnEOI7wEYp5WPA54QQ1wNJoAP4kLH7g8Bbge3oJZXPSCkfP97PQTE+WDy1CIAdDUHqO8MASAmH2kIstA3mHglfe2gblUU+vnD53FGvU6FQ5IbTRrT1GGIt13PQ+tIViVOe72XZjBIANtZ19hNtdR36N2IzytL9bkII8ryunIpKKaXe02aWR5o9bSMMIhm905buaTOFY0meB7/baTlthX4XDV1RS0T17WmLJuzlkUMQbbZyQFPEmOK1KxLXxY2t9NF8bmaPXPo4aZGTn1Eemb6/JOCmKxK3Xie/2y70MssjhyTaNA2OboQ37obtD4JMQUkVXP5fsOzD4CvK8nzTQs1lm9lmYp7XfZwdL5fqaVOMI6SUTwFP9bnvW7bbXwe+nmW/FPCJMV+g4rRgcpGPkoCbHfXdtIf0z7NYUuNga++oRJuUkie3NTK3skCJNoXiJOK0EW1miMSYB5GEE8ypKGDmhDxK8zxsquvklnOnZ2xT165/I1Y1IZBxf57HldP1RRP6UGmzPNI7SqdttKLNTGuMJzW6IwlcDoHb6eAd50xheZUucgt8bnpiPVaPWd/0SLPso2/Qx0B4nOltzH4qU+x1hROU5XnwODOdtt5o0uoZSB8nXWpoP6/9dlm+l2hCs0ogA3anzRhF0B4yyyMHEC9aCvY/C3seh32rIdQK7jw4/990Z23CHBADC59sc9oy+/r028dbPLlsr59CoVAoRo8QgkVTitjR0E0knmLF7Am8uLeFg6Psa2sKRumJJWnpieZopQqFIhecdqJtrJ227rCe1iiE4JzpJRkzVEzMGW3mXDKTPK8zp+szkyxzFvlvF23DLI9MpDR6Y0lK8zx0hOK09sQs8fT9dyy2tiv0ufQgkr5Om0e/6I/YnLbKwmMPFM0oDXRlBpH0RJNMLvLjdTszRFtPLEtPm83BMtcE4LWJtkrDnatp1f9+fR57T9sxnLZkHLbdD6/8HDoOgrcI5lwO867WB1/7i4/5XEEfvlrbNgW/25m9PNKV2dt2vFBOm0KhUOSeRVOKuGtNDRK4evEkDrT0crA1dMz9BmNfsy76moMxpJT9esUVCsWJ4bQRbT3HwWlLpDR6YklLJC2dUcJzu5tp741Rlp8eXnyoLczEQm+GEwP6IOdjOViaJvnmozu4efl0q559IMxyRLP0cLTDtTOctmEGupgu25Rivy7aemMZQSImhX69py06UHqkcX9kyOWRNsHiyHTtzON7nOnh2lLKrD1tdtfKayt7tB+rskgXbYfaQv0eK/SZTptNtEkJzTthz5Ow+c8QrIfKJfCuP8L8a8F5bFHal2VVpSyrKs1cs7N/eeTxFk9WT5tKj1QoFIqcsXhKEUkj8Ky6Io/q8jwOtvR32kKxJC/va2VrfRefestsq20iG/ubewC9KiYYSQ66rUKhOH6MK9G2r7mHXzy3n5+/56yMi/VESrOclLEcrh2MZIqkZUbJ36a6Tt52RqW13ZYjnSyY1L/ePDCE8siatl7+9vphyvK9QxZtRX2dtlHOafM4HcN22sy1TC3xs/1oNy3BWNbyxgKfC02mAzs8fRIfTTHXN51xIOzz0Mzb9j40s6fNFG2RRApN0r880pUWQPYeMX8Wp63WEG12UZrnceEQ0N4bw02SoiPPwVO/gyOvAQKqLoLrfwHVKwctfxwOZk+bx2UvEVVOm0KhUIwXFk1OXwdUl+dTXZ7P+pp2NE1aCcH7mnt4712v0WZUemia5BvXLBzwmHubeqzbLT1RJdoUipOEcSXaXtnfxpPbG/nS2+ZSXZ5v3W8XQrlOZ7RjziErNpIQF08pwu0UGaKtqTtKTWuIW5ZP77d/ntfF0a7IoOfYVt8NQEcoNuh2gDXouV/k/yiDSMoLvMPuaTPXYkb8t/bGmFTk77edGQBi9v2ZrpaVHmmb05bNqeuLN0vkv71s0ety6pH/Rg+dKUb7lkd6ByiP9LmdEGqHll1MjvRwuWMTvoajrHI0UrVzE2ypgbYDOCKdrPeGaAuVMNXbRNFTYSicClf+EBbdCPkVx3wuw8VtS5I0MQeFq542hUKhOPWZVurX2wqiSWaV51NdkU80odHQHWFqSYCa1l7ee9frOITgrx89j4c31/On9XV85KKZWT+DAfa19OJzO4gmNJqDsX5haorcIaWkJ5bMGCWkUAzEuBJtpmjqCMWpLk/fbx8EPRaR/7c/sp05Ffksmar3HdmdrYWTCtla32Vtu+5AGwAXzi7rd5x8r/OYTpsp2szeqMGwyiP7DtcehtPWHIxy2583csf7lxKOp/A4HRQH3KNw2gLW77Mm5PXbzkzU3GuUZ5hrNhMfI3anzXPsf772IJK+rp1+/Mw5bT19B2jHQ3BoDedF9xITSa5I1VD61B/5vitIkQix/NEG6K3Xjw/c7UEP+PYAW4DiGVA+HyYtYeP2RvLjbeySy1j5zo9SuuRqcHmO+RxGSraeNtAdx+Mdva+cNoVCocg9QggWTy3iYEuIfK/L+sL6dy/XcMnccr764FZcDsG9t53P7IoCZpQFeHxbA7c/vJ1ppQGWVZVy/ZmTqe8M861Hd/Ldty/iQHMP580s4+V9rSqMZIy5b8MRvvfkLtbfvlIJN8UxGVeiLWgTbXbsJZG5DiLRNMkjm4+yZGoRM8p0QWKWR4I+R+WfWxqsUoV1B9sozfOwoDJLeaT32OWR248aoi00BNEWyRRtbqfAIdIDqofClsOdbKvvZnt9F5F4Er/HOaTeu35rsZVHmvTt6QOoMl7DfU2maDOGQTsEXpeDSCJFSpPEk9rQ0iNtgqWsdw+88iDupu38j7uDqHSxqmE/JfUdXCtKkfffS6GznB+4arhwA7ChC1p2QzLKZ4DPeIE4aM1VrHJ2EJFeouXn4j3/NqhcDP5iPnvfm3R0tBKWPv73s7cwY/JE6/y/rlvL7sYgABvnXj6mgg3SoSPevqLN5bD6+44Xak6bQqFQjA1fv2qBdd2zdEYJNy+fxl9eq+Mvr9Uxb2IBv/3AUmYaX5JOKw3wvvNm8MdXawF4ekcT1y6exEObjvLCnha+/MBWQvEUF82ewMv7WmkOHruqB6AzFCcUT1pfzGajO5Ig4HEe9/L8k5kHNx0hFE+xv7mXpcaoKIViIMaVaDPDLjr7CBrTFXKI3Pe0NQWjRBIp6trDNmcrfTG+ZEoxf33tMIfaQ8yakMerB9q5YFaZVWtuJ9/rGnR9yZTGzgazPLK/aIvEU1z9y7UsnFzIFy+fS0swhsfpsMSNEAKf22nF6Q+F+k69XLM9FLdKEvO9LpqCUQ609PC+u1/n4U+tYEpx9jILE1NA2t/QswWJFAc8FPndVphHRv+Yx0k0nrJ66wYtj+w4BNsfpKxmLT91p5gi2jn/5d36Y0XTWenoJo8Ih91LaC9cSlv9AWjZTWnXv1jp9BGITIayybDsIzD3Sn78cgM79x9EqzyTez59Dcu/8TQAz1/9Fopspbg9ZSnWtbUC4MvP7DkstIWbHI8PLTP0w+Ps67SdgPJI5bQpFArFmLBoSvqzxukQ/PDGJbzj7Cmsr2nn45fM6vcF6TeuWcAHL5jB1vouvnj/VrYc6eS53c0IAetr2gE4a3oxeR7nkJ22/3p8J9uPdvP8ly/N+nhXOM5lP3mJ9503g69cMW9kT3Sc0dAVYfNhvRLrYKsSbYpjM65EW1dYFzJ9XSjTFZqQ7x1xT1tKk0gprd4cEzPevSkYpbFbf3Pr67QBbDfKGpuCUS6o7l8aCXpYRTShkUxp/c4DcKC1l2hCo8jvpr23/7dfDd0RDrWFONQW4sltjYAejmGP6/W6HMNy2kzR1hmKE07oiY35Phe9rUneqO2kORhje333MUVbdziOEDCpOD20eiCnrKoswFbj9fL0Cf2IJFJWiaSvr2hLRKHmJdj0B33GGRJHxSLOdzSSlE72LPl/zL/iE5BXxpXffY623hg3L5nGrPI8vn9oDzs/fgWvHGjjE3/ZxBM3XZTxQdi8aSsvaYUs95TgcjpwOQRJTVrhLiaTimzPr8/6CmylD32F1FgwUHmkx+nICGg5HqR72tQ3rAqFQjHWnDerjPNmZb/WcDsdzCrPZ0KBF7dT8MdX69h+tJtPXVrNfRsO0xlOMLeigImFPlp6sjttmia5f+MRrlpUSXHAw9b6bg53hDOuX+5eW8PDm49y5weX8vcNR+gMJ1izvzVDtK3Z10pS03jr/IlZzzOeeWq7fp3mEIx6tp7i9GBcibaBnLaQIdQqCr10hhIjOvbH/vQGJXkefvbuszLur2lL/0czhVmhTbTNqcjH63Kwrb6bVuPNb8XsCVnPkefVL/JD8RRF/v4Xt2Y/28VzJvDk9kZSmsxwLkz37cc3LSEcT5FIaZwxOdPt8bmdw+ppM4NR2kNxIjanrTeapNaYN1ffGR5w/2RKI5rU6Iro8+vyPS6E0NPuB3LKZpTlWaLN63LqG3cfodLVSzReTCSewkOCqT3b4JVH4OgmCB6F1r0Q74W8cnjLv8PZHyCZP5kV//EMAHfPX8b8PP1DzJz75rPNM4slNcuV7Rv5b5/Tpq/LQTLeP8HSDFKB/qLUHLBtP85YMmB5pFMop02hUChOcwp9bi6onsDjWxsAeOc5U1kwqZAX97RQFHBTXuClJZjdaVuzv5WvP7ydrnCCWy+cQW17SJ9i0xNjcpGP7z+1m7vWHkIIuO3PmzjcHsLjdLCzIUgolrQSmr/zxC46Q3Feu33lcalA+cHTuzm3qpSVC3InEjfVdbBgUmHWlo/BeGp7IwsmFZLSNA62jG623lihglJOLsalaOsI93Xa9PsnFvg4anOO8ryuIV88723qoSeW7OeC1diGWG6t76LQ58q4MHU5HZwxuZAtRzpZvTPG8qoSq7a8L+abWDiepMjf/z/I9vpu8r0uls4o4YltjXSG40ywzX8zRduCSYUZLpEdvTxy6E6b/fUKx5ME3C7daYslqWvTxdpgiZc//tdeHtl8lPmTCin2u3E4BPkeFz2x5IBz1sy+tpmORtzP3g57noDuIzwCaPscaEfK2O7twrvOEOAlM6GkCs68GeZeCTMvAZf+uniktI7rzhLVr0f+67fjSc0qT+03XLvPzDOv20konsoYHwBpp83tFP0+gMw3PYc4PuLFPWAQiSOrkzuWqJ42hUKhOPm44oyJrNnXyqwJecyuyGd2RT7XnTkZ0L+EtAep2blvw2FAH2l03qxSzI/a+o4wwUiCu9Ye4pZzp7NyfgW3/WUjAP9xzUL++4ldbD7cycVzyukKxzlgzJR75UAbl83LfYqynZaeKL97uYbVO5q4bF5F1jaV4dLYHeGm367nW9cu5MMrZg55v+ZglM2Hu/jK2+ayqzHI7saeY+90Avjr64f50TN7eOMbl/erLFIcf8anaOtXHmk6bT5C8RRSSlb9fA0fXlHFpy+bfczjSilp640TT2nsaAhy1rRi67GDrb3MKAtQ1x6msTvK9NL+TbhLphZbTb//ef0ZA57HFG0DhZFsP9rNGZMLKS/wWs/TLtpMh7EkL0vARTwMux/jMq0OGZoJ8XngGbhh2MQUZB3hBOF4ipKAh3yPi1hSY3+L/iZjCrtsbKztpKUnRt+XxCYAACAASURBVEtPK2car1ue1xBtLgHd9dB1BA6+AAeeg95mPhPp4X1eB+V0I95wwZy3wYrPc/faA0wgyEWTJI/s6ub8S69h8flXQH75gOc3I+7jKQ237Q3aZxNtphMVT2pW0uiAc9psThukUy1NTKct25ub2dN2vJqwBxNtx7080hqurUSbQqFQnCysWjiRbz26M2OWrElFgZfmYBQpJUIIHth4hF0NQT560Uye392C0yHYfLjTCtgC/ZqhyXDnPryiirkTC/jRjUsIRpO8e9lUvvfkLt441MHFc8rZVNdp7ffYmw1DEm2JlP45XZrtOucYvHpA79erbQ/z4t4WjnSE+dP6Op783EXDdslM3jzchZTpMUVDZesRXQxfUD2BWFJj9c5mYslUxkihk4HVO5roiSZp7I5ahkMypfGPTfXctHTqaRMqI6UkpfVvkTrejBvRJqUcpDxSvxCvKPAST2q09cZp641lDJAcjGAkaUXCrzvQliHaalpDLJ1RQk80SUcobiU12lli9LVVl+excn6WN6VIF7x2Bxftfolvukrwbq2FyVOgZAaUzQFvPlJK9jf3cNM5U5goOvGiP4e5tvkpZi9fqS0IhXgItv4d1vwYehr5FkAY+D4QKNP/+EshYPyxbpcRcRbyltgGCp1hXJ3TCaccrEzuZubBKF5XAndnEq8rjquhDNadqYtAdwDcfvAWornz8TW+wcXuFKlUgquS3fDPv/FN2UrYFeXqzTvhdf1NFOGAaefDrMvoijl4YfsROl3lfOqL34UCvYzhpW2vE0mkKD93Lt/b9jr3zzof8rPX7NtxOwXxVKbTZok2t9MSNbFkit5YErdT9CspTPeHZYq9vt/UmXNvsvXrmWWzx6OfDdLDxO1jD0Cfs1eYxckdS8w3OqfqaVMoFIqThooCH49+egWzyvtXAE0s9BFNaPTEkty9poZfvnAAgH++eZSkJrnt4pnctfYQz+xoIs+jV5/Ud0ZIahKHwErUfteyadYxF04uZENtBwAb6zpxOQTXnTmZ1Tub9GqeQcTTwdZe/u2vm9jX3MsFs8r4yhVzWTqjdMjPde3+NooDbvxuJ997cjd1HWFSmmTNvlauXDRpyMex86bhRA7WJpKN3Y09CAHzKws4YqzjcHt40Jl4m+o6mV2eP6Jh58mUxtb67mGFnUTiKevvqjmYFm3P72nh6w9vpyTgHvHrdqqxemcTX31wGy995VLKbGYJwKsH2rj7lUP86paz+33hn2tGfHQhxDTgz0AloAF3Sil/IYT4T+A2oNXY9HYp5VOjXeixiCRSJFK6P9+/PDKJ1+WwLlTNZMKGYwyyNmntTdd0v3qwzXLnookUDd0R3lU+lSOdYTpC8axljUtnlOAQ8G+Xzs68yK97Fd78G+x8FOI9eEvm817nZvzrns48QOEUEoGJPEgb1Ts68LzZy26vIPrQZCiugMIpMO08ptdF+KznEP4X1kGoVf9zdBPEgjB1ObzzTr72ZC2VyQa+cI4Tuo9CpAPCHdB1GNmwBRnuwJHSe+/8wC9N/Wfo22TYRSJSygecXSRwEcVDSbQHnn2w3/N2AH8zr9GdQCcQr+DCZALpTNBcuoJZy66Aomkw+WzLMXP0xvj6luco93v5VEG67tzndtJhpFhC9vTJbHhcDkLxVIbLk1kemdnTlu91ZYS3mMcAW3mky5nVTas0nLZs/Xpmn5z7OPSzgW24dp8Szl/efDbiOGsnp3LaFAqF4qRkoHaKikL94vSnq/fyp/V1vGfZNM6dWcr/e2gb588q5aal07hr7SHW7m9jeVUJte1h6jvDhOIpppUGsrpGy6tKuff1w8STGptqOzljShHvWT6NR7Yc5Yv3v8m5M8t433nT+32+Hmjp4YZfr8PrdvKJS2bx6JsNfOIvm3nhK2/J6LeKJzX++Oohzp5ewvKqtKCTUrLuQBsrqidwxpRCfvTMXmaV59EVTvD0jqZhiQ9p1IIKISzHrH6QiqNs7G4MMqM0QJ7XxewKPYH6YGvvgKLtUFuIm377Kh9dMZP/uHbhsM4F8NjWBr70wFZe/MqlA7bo9GVDbQdxo52m2dbbuMVIvNxxNJhz0ZZIaaSMkLdIPMXXH97GV6+cf8ywu7Hm9UMd9ESTrNnfyjvOnprx2O/W1PDyvlZ+/uy+Ef3dDIfRSMIk8GUp5WYhRAGwSQjxrPHYz6WUPxn98oaOGbef53HS0dtftBX4XOQbQR+HjPAQM+3R5EBLL0JgDac0ae3Rjze/soCNtZ1EEyl8bieH2vTG21nl+dS1h9lyuCsj7t9kRlker92+kooCn55wWPsKvPpLOPQyeApgwXVwwac4lJrODb96mXtumsFbpjr02Pq2fdC2n96WIxyR5ZTOupjA1EXcvXojNxRFmBWIQ8su2PME14GulDblQd4EPZBjwXVwzgdh2nkgBA0BH7sj1XzhkhX91nnHSwf4yeo9vPrl86l0RXh91wG+/vgBqqdU0tt8kBJXnEmLLmX5vGl88q+bAbhgVhnra9rYcfuFfPjONVT4Jb+5aR7Egmzcd5hfvHCQb9+wmMriPFxlM/GVzeBz92xg7f42vn/OYmYtn95vHWV5HvK9rn5ul9+jh6iY6ZGDRv7bMAWX3cb3ZyuPTGmEYknyff3/W/Qtj/S4HAO4aS787uyCzvxgOV6liS6HoKLAmzEbDxjRt3S5WAuoIBKFQqE4Vago0L+E/NP6Oi6ZW84Pb1xsDfMuDriZkOelwGh3WDCpkKQmOdoVob033u86yuTcqlL+sK6Wf+1qYmt9F+8/fwbnVpWyauFENtZ2snpnM+sPtnHH+5dmfGY/trWRSCLFM1+4hGmlAa5dMpnrf/MKP392H9++Tm87qe8M8+l7t7D1SBfnVpXywCcvsPY/2BqiKRhlxewJXLNkEkc7I3zkopnc+XINT21vHFJpYjSR4o6XDvL41gY0KXnmC5dYAXRHOyNWGSnAbX/eiMsh+NFNSzKSo012NwVZOEmf12u6nGZ/XzZ+/0oNUuq9fyPBLGHd39wzZNH2yv5WKynbLtrePKKXtZojqHLJdx7fxY6Gbh751Ap2NHTzzzcbWDy1mI9edOx+wXhS4/6NR3jr/Iqcizzz7+alvZmira03xisH2ijyu7ln3SFuOGuKlRo/FoxYtEkpG4FG43aPEGI3MCVXCxsuZmlk1YQ8djYELWEFWElFpu1uj+k3ExillHzsT29QUeDL+I8O+l8KwA1nTeF/ntnD5rpOLpw9wTrOrAl51PQdrC2lPpj5wLPQWUdFpEMXYa17IRnRyxKv+AEs/ZDVWxZo7SWFkw5nGVRO1Qc2Gzy0pobv1e5myw2r8Ptc/PLpp2HWHL64aq6+QW8LX7nvdWojfh783OUDvk4+l4OWAdIjtxzuQpOCdXVRblw6jb0iRY0M85YZVfyh3oEjCbf5C8j3pt+AVswuY31NO9tbJW+0uXEIaM+rpmyil7V7S1kn8/4/e/cd31Z1NnD898h7xHvEI45HHGdvMsgkISXsWWaBQlktq7SllLLaty8thZYueNtCmS2BsAl7lwxIiLN34jjDK7ZjO17x9nn/0JUiO7bjJLYlOc/38/En9tWV9OhK0bnPPec8h6TxC9r0ioVY70NnSZeIMDg6+Igql0F+9sW166xiIUHdHIPeUdLmKCAS4Ht4eGRjs30YSEgHj3u4h+3wv+2LkDhiHxge2OFrc/T09tUYcBFhyc9P67PhmF3RnjallPIujp62YH8ffnvhKGdC4jotY/zgSJbsKGV4QhgVh5pYl1dBSVUDMzM7rpI9OyuWrPgB3PnKOlpaDZMGR2KzCU9fMwmAf3+zhwfe2cxPX13PIxePdp63LdtZyujkCAZZdQNGJ4dz1ZQUXvh6D7OHxpIWE8LlT62gpqGZUzOi+XZ3OdX1Tc6EabmV7MwYEkN4kB8PX2g/v1owaiCLsvP4OqeM0zqavuLiyS9z+NsXOYxNDmd9fiV/+mwHtY0tDE8IY2tRFVV1zYQH+1FUWcenW4oB+8n+whunOmsRgL0jYW/ZIS6ekGwdX1+SIoJYnlOGr4+N+SPi2yS9ZTUNvJadT2iAL9v2V1Na3dDm8brDkXQ4Rpp1x9KdB5icFsW6vIPORdZbWo0zUd1cWNXV3Y/Litwy9pUfwhjj7FjZVnT05ympqufWhWtYtaeCrVNS+O2Fo7vc/+ucA2wqrOSmWRndimtHsX242ZIdpW0qt7+3vpCWVsMz107ihy+t4d63NrD41hk9UuSmIz1yNiciqcB4YKW16TYR2SAiz4pIhwNoReQmEckWkezS0tKOdjkmBw81Mc22meeqb2EgZc6eN7Avrp3pU8zobX8mmHpyrQ9tS6txluFfs6+CPWWH2Ft+5Afasc85YxII8LXxzjp7edxca12N9NgQUqPtVy4igv3sa4U9PRf+Pg0+fRA2vwVFG+yJ2qTr4KrX4a7NMO1HbYqBhDoLkbTw4caiNsM3d5ZUExPqT2SIP74+NiKC/CirdVk/JTSOnQ2RBIeGdXmcuqoe6fiPuHyX/cutoKIOfx+b8wu61dh7uxxLE/jaxLkOzGKrZHCrgS+329/PrUVVpMaEHDGM0dGT1VUlomnp0Qwb2Pa1ONZpcw6P7GYlI0fS4lq50BFTgN/hnjbH8Mj25f7h8JBGZyESP1un8Z+SGsmwhCPfB8fj9mUSFejn02tfHsfCzzmnzf2xKKWUOrqkiCDiwwL45VnDSY7suHDZxBT7Kd7whDCSIoLIK6+jobm10562YH9f/n3DZAZZI0AmprY9Rbx6Wip3n5HF4vWFLPjzUlbvraCqvon1+ZXMbLdc0s++k0VqdAjff24VZ/91GfVNLbx68zTumJdJc6vh6132OfMrcst44ssc0mJCSIlu+zpOHRLNgABfPtxU5Nx2sN0UG7BPp3lqSS7nj0vk7VunMzQ+lKeX5AL2c0OAPGte21fWOdAD54xgZ0kN76wraPNY2/dXOY+ZQ2Z8KN/klvHIh9v419LcNvv/e8VeGppb+bVVyO7rXV33ti3POcCvFm+mrvHwhe+c0mNL2goP1rFtfzWzhsYyMCzQWVwmp6SG2sYWRiWFUVLd4Dw/7gl1jS3sKq2hobmV8tpGiqxz4K37j560/fS19WwqqCIlKphVu8u73Hdf2SFu/vdqHvlwm3MdZ1fNLfbndwyDraxroriqgRHWhYmNBYd7GN9eV8iwgQOYlBrFo5eM4ZdnDu/Vc64TPnsUkVDgDeDHxpgq4O9ABjAOe0/cHzu6nzHmKWPMJGPMpNjYzqv/dVdlXRNTbVuJa8rnHr9X2iQ0NQ3NXNO0iNSt/+RF/0fIKHyPN/wf4hHfpygu3AvAm2sKCKaeiupa5xhehwM1DfjahKSIIC6ZmMxbawvIrzjEW2sLGBofSrC/L4Ojgwmjhgt2PQAvnm+fT3bWH+AnW+Ge3XDHGrj6TVjwO8icby/W0Y5jAuO+8kP88KU1PP7pDudtO4pryIw7fHUrKsSf8tpGckqqnWuslB9qJOooQ9/si2sf/o+8eH0h2/ZXUVJVz/6qenxswtc5ZRhjyK+oIzEikGiXKk3B/j7O5CM5MojB1lWvDzcV4edjH473mXWFaev+qjZfSg6O5LSr4Y33nzOCJ6+a0GZboL99jPOxDo/0a1euH9pXjzxc8r+mofmIcv8AAe0eY9ygCCZ0MqH30UvGdniV5/DwSPf3fPU17WlTSinvEujnw4p75/G9qYM73efSU5L54ZwMRiWGtRmKnxHXcdIG9mGXr91yKgtvnOIcgunq1tOGsOimqRgMt/xnNZ9vLaal1TCjXe9dRLA/H9w5k7tOH0pKVDAv3TCV4QlhTEiJJMTfh692lPLRpiKufHoFoQG+/F+7cwqwj7aZkRnjTPA2FVQy/jefOs9jHB77eDsAP18wDBHh+ulptBoYEODr7FV0zGv7cnsJieGBXD89lagQ/yOGPW6xyvsPTzh8Tveb80fx7PcnMTY5vM2abcYYXl+dz8zMGC4Yn0RYoK+zCmZn/v3NXp7/eg/XPvstVfVN1De1OGNzdFo89M4m3lid3+lj/O2Lnfj5CGeNSiAu7PB6fY6hkVdNsX8menKI5PbialqtpSOKKuudPW07imtotooBVtY1cd1z37Jw5T7n/eqbWli5u5zvTU3hslMGsbOkhoraRlpbDe9vKGLBn5dwz+sbAHvBuVsXrqG2sZlWAxvyjlzS4hdvbmTCbz5l5EMf8+yy3eRYldKvn5GGCPx3ewkAeeWHWJd3kAvG2wcZnpYVx6mdrMPcU07o7FFE/LAnbC8ZY94EMMYUG2NajDGtwNPA5BMP8+iq6poYJPYDeaHPcpr3rHDe1lRfw+T6r6mLGc0Y2cUv6v9EtFRzkc9SRr02k9a/TuDm9RezKeAHfO1/GzVf/c1eIt9yoKaB6FB/bDbhhhlpNLW2cNVTy6k4UMSfRu2BF89n7JuzWRF0J+kln8Np98Ft2TD5RghL7PZrcPQcOb4svtxWQkurwRhDTkkNmfGHvwSjQwMoq2nkkQ+385NX19Hc0kpFbRNRIV13mbsurl1SVc+PX1nL/7y7xXnl4LyxieyvsvdG5h+sIykyiOjQw0lbkL+vc3jk4OgQYkID8PexcfBQE6OSwvnOyHiW7CzlQE0DeeV1zjHbrhxJX3eTLtfj09Bsn3cmcuSi0Z1x7Nemp82ZtLUdHmmf03Zk4tt+TtvdZww7avd7e4cLkZx8iYtzTttJmLAqpZS3al+Uq72E8CDuWTAMXx8bSa5JWyc9bQ6xAwI4NaPzE9wp6dH89fLxlFY38ODbmwn292FCypEXSgP9fLjz9Ew+uHMmIxLt5xv+vjamZcTw2ZZifvHmRkYnR/Du7TM6vIgM9qGW+RV1VB5qYkVuGcbA7z/aRouVQSxcuY+31hZw48x051ypC8YnER3iz9hBEQyyeiELDtbR2NzKsp0HmDMsDhEhMy6UnVbSVlHbyK7SGrYWVREW6Ntm3tWgqGDmDotneEIYu0oPJ3lbi6rJr6jj7NEJ+NiEaRnRLMs54OwF6siO4mpSooJZs6+Ch97ZzK7SGoyxLzu0+0AtVfVNvLhiL69m53V4/237q1i0Ko+rp6aSEh1MvEtP27q8g4QH+XHWaHvvYvshko7z1bzyQ0d0gByNawJYcLCOokp7otnY3MruA7XUN7Vwwwur+HJ7KQ+8s4mVufbkdc2+ChqbW5maHs3kNHvxmVV7yvnz5zu5deEaCg/WsSg7jw35B/nr5zvZWFDJo5eMBXAuO9Fqvdd55fYOmbnD4kiJCua5r3ezo9j+fkxOjWJscgT/tXpSHT2epw/v3fUFXZ1I9UgBngG2GmMed9meYM13A7gQ2HRiIXbPwbpGJkoxtTFjqS7dR8byu2HIYIgbxrhD3xBo6imc8SC3L9pErFSyP2EuFYU5PDFkNdGmgg2lZexNOQ+ffcs5demDsOIR+0LNIy8ksrSER1gMf/kZaZV57A5ohjogEFgORKRgS5lGsF8QTLgWko68mtMdNpsQ4u/jvBJSVtvIurwKEsKDqGloblNVKDrEn40FlRyoOUhTi2FXaS01Dc1EhXTd0xboZ3MOj3xnXSGtBr7JLSM5MgibwI0z03lrbQFvry1gb1ktZ4wYSKRLcZVgPx/n8MbU6GBsNiExIpA9ZYeYmBLJjMwY/rNiHze+aF9M0/VKkoOjR/FYF2pMtL7gVu2uIMjP56iNiUPHc9pcqkf6HC75X93Q7CxYc7THOFYDtKdNe9qUUqqfcgx5jAz2O6511NobnxLJheOTeGttAadlxR6x5mhXZg+N4bOtxQT62fjTpWM7HEHjMNqqnrmpsJL1+ZX42ISdJTUstBYQf+idTcwdFsedp2c67xPo58NLN04h2M+XiGA/Qvx9yK84RPbecmobW5xrzmXGh7J4XSHGGB54ZxPvbSgiwNfG2EERHZ7DZMSG8kptHhW1jUSG+PPx5v2IwOkj7JW0pw+J4ePNxew+UEt6bCgFB+vwsebSg73XaU9ZLbfNzaS0up7F6wqZbvX+zB0Wx9vrClmyoxRjYEthFa2tps1wPmMMD7+/lQGBftwxz14pfWBYIMVVDRhjWLvvIGMHRRAe5EdKVPARPW3vbyzitoVrAfvUoQ/umNnluV5NQzN3vLyWu04fypbCKvx8hKYWQ9HBOvZX1hM3IICS6ga27q/m6aW5ZO+t4PcXj+afX+Vy28tr+eCOmazILccmcEpalLMi+BfbSnh/QxHfGRHPY5eMZfYfvuSeNzayo7iaSyYmc8nEZJ5asovV+yoorqrnnL8t4+IJydQ2NGMT+O2Fo1myo5Sfv7GBt9YWEOhnIzkyiDlZsfzl852U1zayMrecmFD/o16g6EkncvY4HbgamCsi66yfs4BHRWSjiGwATgPu6olAj6ayronBUoxPwijuaLwNn8YqeGoOfP035jV+QaVfLD5pM1htsviodTLp8eEc8EvizbhbeTz8F9zv9zOSL/w1VzbdxxfTXoCxl8PuJfDq1dxb/FOmNGVD4jiYdhsHJt7F66FXUTnnf+F7b8Ad6+Cip+Dcvxx3wubgSGimpkfhaxM+3VLivEqT6TLcICrEn/yKOuqb7AlY9t5ya3vXPW0BvvaeNmMMb64tYFBUEMbAa6vzGRIXyvCEASRFBPG3L3KobWhm/oj4Nl++wf4+hPj7cM6YBM4YZV+M03F1bVJqJNMyopmWHk3loSbGDopgYsqRa6h0Z3hkR84YORB/Xxvf7ik/pvs6Ey6XNcKcPW1+tjY9bY6S/+11tlD1sfC3ipecjEmbzmlTSqn+LSnC3uOU3oMnsT9fkEVEsB9njj620vJzh8fj72vj/rNHHDWeUYlW0lZQyYb8g5w+PI5RSWE88PYmHnh7ExMHR/LklROOaLuHDQwjJToYESEpMoj8ijo+2VyMv4+NUzPs8/0z4wZQVd9McVUD3+wqIzMulLAgP2YP7XhaUEacvT5CrlXl/OPN+5k0OJIYa22w+SPi8fex8fTS3VTXN3Hhk8uZ/6evnL0+OSU1tBrIih/A/BHx1Da28O8Ve7EJzkIri1bZe9iqG5qd8/Ac/rujlKU7D3DHvExnNfS4sEAam1vJr6hjR3G1c63ikYlhbXraWlsNf/18JxmxIfzsO0PJLa3l7bVt5/O19976Qr7YVsLjn25nc2EV41Mi8fe1UVhZT2FlPTOGxOBrEz7bUswbawq47tQ0Ljslhb9/byLltY08+WUOK3LLGJUUTligHwG+PoxLjmBRdh7VDc3cNncI4cF+/GhOBluLqogK8eeBs+1l+SekRLJmbwX/WbGX0uoG/vHVLv69Yi8XjU9mYHgg80fE42MTvt1dzpC4UGw2YU5WHMbA0p2lrNxdzuS0qG53IPSEE6keuQzoKNJeX5OtI3U1lcRIFa2xGaxiGC+OW8jNB/8En9zPdOCb6CsZHXg4+RgYFkhCRBCFB+vYmF/JqRnRJEUEYRNhnW0Ec8+5AM58DPYs5aGFX9KUeSa//a69qmQMcMm5vfM6QgJ8obqBBSMH4muz8cmW/c7Fwl0rNjkW9wv0s1HfZF/vBOhWT1urgY0FlWwtquLX543k3fWFZO+tYHSS/crPD+dksCH/ILedlklKdDCtVqWcllZDsLWG2RNXHk5OkyOCgTImDI4kwNeHl2+a2mUM04fEcO7YxE4nNncmPMiP+cPjeX9j0TH10jm+aF2HJQb6Hx4e6Rg+eciaL+daHdOh/fDI42X/Ujn5kjbtaVNKqf4tyN+HpIigDqdFHK+E8CCy7zsd32O82JkUEcSGh77TrXOFyBB/kiKCWJZzgL1lh7jslEHcPjeTt9cWMG94PJPToo56wTE5Mpht+6v4OucAC0YNdF6Ad1xs/3jzfspqG7n7jCwun3zkUkcOjl6bnJIaYkMD2ba/mvvPHu68PSE8iMsnD2Lhyn1U1TdRWtNASlQw1z77LS9cP5n91jywrIGhJEcGE+zvw/q8g6RGBzuLuy3LOUBYoC9V9c1sKqhisFVIr7mlld++v5XU6GCudpnH6Fh/9v2NRbQamGINQRw7KIIPN+2nuKqe+LBAPtlSzI7iGv5y+TjOG5vIh5v28/TSXC6dNKjT4hyOIZpfbi/Fz0f43tTBlFTVs7eslgM1DaREBzMkLpTF6wvxtQk3zkqzXt8ALp2U7Jzb9v3pqc7HnJwWxbd7ypmWHs2YZHuCec20VDbkV3LF5BTnskcTBkfyyqo8/rV0N3OHxZE1cAD/WbGXm2anA/bPxakZ0SzdeYChVk2J0UnhRAb78dLKfRQcrOOmWemdvpe9od+cPfpW2d84W1QaEUF+5DeFwVWv0XLlG7zbMpWtyVe0qTYYHxZIQngg2XsqKKysZ1pGDP6+NuLDAilwLJLo44tJn8PC+qmER3R/FfkT4ajMOH1IDKcPjyO3tJZF2XlcMC6xTY+XozjIvOHxRAb7kW2Ny43sYJ04V44vsEc/2o6vTTh3bCIXWWVnx1hrS3xv6mAevWSss8qSzSZEWh/yjnq4LpyQxM2z0zucUNyRtJgQ/nbF+ONKgC6akNRpHJ1xVo/sqKfNZXHtCqtiVIfrtDlK/p9gL1lYkN9JmbjoOm2qPxGRBSKyXURyROQXHdz+fREpdRmFcoPLbSki8omIbBWRLVb1ZaX6hVdvmcbPF2T16GMea8LmcCwXd0clhTnXQBubHMGopHDuP2cE0zKiu9VuJUfaK2fWNrZw62lDnNsd01ocyYVjzlXnjxOMv4+NXaW1fLTZPtPoOyMGttnn1tOG4GMT3t9QxGWTBrH4thlEBvvzwtd72F5cjb+PjcHRIQT6+TAr096jNyQulMHWOZ0xcNGEZPx8hE0uwxufXb6bnSU1/OLM4W3Oz+KtpR8WryvEz0eccwsdQ0C/2FaCMYYnvtxJanQwZ49OQES4aVY6u0pruXPROuY89iUfbDxcoRPsC6av2XeQJ4TucgAAIABJREFUH87JINDPRlOLYWRiOIkRQazddxBjICE80DkX8fxxSSSEH54HePtc+3DVxpZWpqYfPq6zrF7MH512uJx/oJ8PT1w5wTlUFHC+jrqmFq6ZNph7Fgxj7QPz2wx3PNNaPHyIVVPCxybMGhrLt1aFyinpXb+fPa3fJG3BNVYlmchUIq3KigA1g2Zze9MdtIYn42MT58l63IAAEsODKLP2m251ZSdFBFFw8HB3cWVdE00txtk13dtC/H2JGxDAkLhQLhifxBWTU1h4wxT+fPn4Nvs5Erj5w+NJjw1lX7k9ZteiIR0JsF7/N7ll3Dkvk6gQf84fl8hVU1I4c9TATu/nSAY7KrM/NT2ae88cfsT23jBraCzRIf7dXqMNXOejHf7inTU0huump5IWE+K83bEeX1dz2k60p+2W2RlcOaXzSlz91eGetn7zlaNOUiLiAzwJnAmMAK4QkREd7LrIGDPO+vmXy/YXgceMMcOxF+oq6fWgleojSRFBHS4m7elGJYbjqO0xKunYF0d2FBWZPyKerIGHR0XFhPoTEezH9mL7sk1HW9jaxyakxYSQU1LD66vzGTco4ohlCuLDArlldgYDwwK5+4wswoP8OHtMAl9uL2XN3goy4kKdI4zmW3PhMuJCCfTzccY5Y0gMQ+MHsKmgkvqmFu59cwO//WAbc7JiOWNk/BHPB7ClqIoxyRHOJZOGxoeSHBnEZ1uK+WZXGZsKqrhldoYzyT5rdAJJEUG8v6GQqvpmHnxnk3NNZYDXsvPxtdkrcV4y0d55MCIhjMSIIEqspQQGhgcxJjkcEY7o1UqMCOJ7UwcT6GdjUurh5GlyWhTf3jePmZldV6ZPjwkhItiP1OhgZ3Lb/gLBWaMHMjk1ypmgAszJsu8bEezn7IHrK8c9PNLThNVZ42aj0ogO2cqmwkouf+ob51A3xzylkABf6ppaiAsLdBa2SAgPdP5HSooMYs2+CufjOtagiDlKMtRTbpqVTn1TKyJCRLA/v7uo4wqFszJjuXl2OmeMHMjynAPOCjhH62mbPzye/PJDXHrKIOfVhJAAX+dCk51xJInHOg+tp/n52KxYO6+c1J6/rw1fm7QZdxw3IJCHzrWveeJjfVN/vtV+7jQy8cgvbNdFtU+E44vpZKNz2lQ/MhnIMcbkAojIK8D5wJaj3dFK7nyNMZ8CGGNqjnIXpVQfGGWNNEqPCSE86NiTzuEJYfjYhNtcetkAZwXJVXsqOCW1e/OfMuJC+GJbCfVNrTx84agO97lr/lBumzvE2baeMyaR55bvYdWeCi4Yd7hq+enD40mNDmaG1cOUGhNMwcE6JqVGMioxnE+27Oe+tzbxxpp8fjgng5/MH3pEjI5F1uHw0EjHazt9eDwvf7uPuqYWokP8neXvwd7uv/mjU2k1hrKaRs57Yhl//GQ7/3P+KBqaW3h9dT5zh8UROyCAn8zPYtjAMIYnDCAx/PCorcTwQKamRzHdSjLb++VZw7h+RqpzSSVnzN0Y+WWzCY9dMpaoEL9Oh29GBPvz6i3T2mxzJIOnpEb1+Tq4/SZpi2osoNY2gJCgSKJC/Fm1p4Km5lZnT5rjyk9IgA8HauzdvQkR9jf11IwY54fUflWgyLnieanV+3Ksq88fr3nD44++ExAe7Ofs3XJMshXBOXG0MwPDA7n3rGPvFTuctLn/I7Ogix7Bjvj72NqU+29PRPD3tVFS3UBW/ABGJh45Hn94Qhh3n5HFzE4mD6uu6Zw21Y8kAa61svOBKR3sd7GIzAJ2AHcZY/KAocBBEXkTSAM+A35hjGnp4P5KqT7iKEbimCZyrGZmxrD6/tM7PAcbEjfAmbR1R0ZsKB9s3E+Ar41zx3a+bJRrYZQJKRHWSLE6hrr09IUH+/Hfu09z/v2dEQOJDgkgItifUUlhLMrO4401+dw5L5O75g/t8HkCfH2IDPaj4lDTEcM7Tx8ez/Nf7+HrXWX8+PTMI4akOnrpEsKDuGZaKi98s4fvThzEjuJqymobuWZaKmA/x3SsB5joshTCwPBAAnx9OkzYwN4zdqz1EVw5eiKPRUxoAL86dwRjrYIsfcn9Z+A9JK65iINBiYRgH+c6b3g8549LpLy2kffWF3HaMPvJtiPpiB0QQLL1wXBU+QF7T1tzq+G9DYU8+tF2522xfTQ88nikx9p7CSOC/HqtJ8ORtAW5uafteAT5+xx1bHuAj43G5lYunJDU4ZUwH5u0Gaeujo0jWesqeVbKS3T0IW7f9f8u8LIxpkFEbgFeAOZib3NnAuOBfcAi4PvYl89p+yQiNwE3AaSkdF64QCl14mIHBHDz7HTmDTv2k3jAOTqqI1nWfKijzWdzcIyCWjBq4BE9SF09/9ljEnhqSS5ZnSQ4ANeemsq1p6YCMNIaBjolLYo75mV2eh+wJ19V9c1thiGC/TUNCPCloaW1y0XYAX7ynaG8t6GI+97eiDH2eXbTh0QfsZ8jaRsQ4OuxQ22/Pz3NLc/bL5K21lZDYut+aoLtQ/xGJYU7xyQnhAdxo8s42NAAH6JC/Anw9WFKejSPXDS6zZUMR8b+yzc3UtvYwmvWivF91dN2PDKspC2yB9ZF6UzsgAB8bOL24ZHH4/rpaczJ6nrxwwA/GzWNcMG4pC73U8fHUa3zWNfmU8oD5QODXP5OBgpddzDGlLn8+TTwe5f7rnUZWvk2MJUOkjZjzFPAUwCTJk3q/nhwpdRx6a25+ZdMGkR0aECHo3g6Mj4lgtAAX66Zdmzz3783ZTC5pbVHJFadGZccwf1nD+e8cYlHveCfGT+AiGC/I5ZE8ve1cfu8IdhEjlr7ISzQjwfOGc6dr6wD4DcXjOrwInmiNQpuYHj3itudTPpF0lZdV0+SHGBz6NGvRkYE+5MUYV/bzMcmR5RedUzSrG1s4dFLxvDklzkUV9Uf1xjnvpISFYKPTZwVJXvD1VMHM3FwpFeuMTYoKphBUV13n4cG+DI8IUy/JHrJuOQInrxyQreHhyjlwVYBmSKSBhQAlwNXuu4gIgnGGEeptPOArS73jRSRWGNMKfbet+y+CVsp5Q6hAb5dDnNsb3B0CBt/9Z1jXv8rJTqYf107qdv722zCDTO7V7L+sUvG0NLa8bWjm2ZldLi9I+eNTWTRqjw2F1Zx0fiOL5I7KkTq+diR+kXSVluyl3BpoSn86EnbA2ePoLGl8+kDSRFB+PkIp2XFcemkQcwZGkvugdo+XTzvWPn72siIDXGOHe4N0aEBR63E482euHLCUStvquNns9mHbijl7YwxzSJyG/Ax4AM8a4zZLCL/A2QbYxYDd4jIeUAzUI59CCTGmBYR+RnwudgbldXYe+KUUsrJ0845e2qUjIjwj6snUnmoybmWXXshAb7EDghwLlGgDhNj3D/qYtKkSSY7+/gvNlYfLGP7sjdIGDGLpPRhJxzP2n0VZMYPOKIb2JPtOVBLkL9PryZuSinVE0RktTGm+5eET3In2kYqpZQ32VlcTXRoQJv1iU8WXbWP3pOVdGFARDSTzrmpxx5vfErfLKTdk1KPsvaHUkoppZRSni6zi2IqJzPvm6CklFJKKaWUUicRTdqUUkoppZRSyoNp0qaUUkoppZRSHkyTNqWUUkoppZTyYJq0KaWUUkoppZQH06RNKaWUUkoppTyYJm1KKaWUUkop5cE8YnFtESkF9vbAQ8UAB3rgcfqCN8UK3hWvxtp7vCleb4oVvCveE411sDEmtqeC6e96qI30ps8XeFe83hQreFe8Gmvv8aZ4vSlWOLF4O20fPSJp6ykikt3ZKuKexptiBe+KV2PtPd4UrzfFCt4VrzfFquy87T3zpni9KVbwrng11t7jTfF6U6zQe/Hq8EillFJKKaWU8mCatCmllFJKKaWUB+tvSdtT7g7gGHhTrOBd8Wqsvceb4vWmWMG74vWmWJWdt71n3hSvN8UK3hWvxtp7vCleb4oVeinefjWnTSmllFJKKaX6m/7W06aUUkoppZRS/Uq/SNpEZIGIbBeRHBH5hbvjcSUig0TkSxHZKiKbReROa/uvRKRARNZZP2e5O1YHEdkjIhutuLKtbVEi8qmI7LT+jfSAOLNcjt86EakSkR970rEVkWdFpERENrls6/BYit1frc/xBhGZ4AGxPiYi26x43hKRCGt7qojUuRzjf/RlrF3E2+l7LyL3Wsd2u4ic4QGxLnKJc4+IrLO2e8Kx7ex7yyM/u6pr2kb2LG0jezRGbSP7LlaPbB+7iNcj20i3to/GGK/+AXyAXUA64A+sB0a4Oy6X+BKACdbvA4AdwAjgV8DP3B1fJzHvAWLabXsU+IX1+y+A37s7zg4+B/uBwZ50bIFZwARg09GOJXAW8CEgwFRgpQfE+h3A1/r99y6xprru50HHtsP33vo/tx4IANKs7wwfd8ba7vY/Ag960LHt7HvLIz+7+tPle6ltZM/HrG1kz8WlbWTfxeqR7WNn8ba73WPaSHe2j/2hp20ykGOMyTXGNAKvAOe7OSYnY0yRMWaN9Xs1sBVIcm9Ux+V84AXr9xeAC9wYS0fmAbuMMT2xSHuPMcYsAcrbbe7sWJ4PvGjsVgARIpLQN5F2HKsx5hNjTLP15wogua/iOZpOjm1nzgdeMcY0GGN2AznYvzv6RFexiogAlwIv91U8R9PF95ZHfnZVl7SN7BvaRh4HbSN7hze1j+BdbaQ728f+kLQlAXkuf+fjoV/4IpIKjAdWWptus7pKn/WEoRQuDPCJiKwWkZusbfHGmCKwf2CBOLdF17HLafsf2lOPLXR+LD39s3w99qtFDmkislZEvhKRme4KqgMdvfeefGxnAsXGmJ0u2zzm2Lb73vLWz+7JzGveG20je5W2kb3PG9pIb2sfwYPbyL5uH/tD0iYdbPO4kpgiEgq8AfzYGFMF/B3IAMYBRdi7fj3FdGPMBOBM4FYRmeXugLoiIv7AecBr1iZPPrZd8djPsojcBzQDL1mbioAUY8x44CfAQhEJc1d8Ljp77z322AJX0PZkymOObQffW53u2sE2Tzm+JzuveG+0jew92kb2Pi9pI72xfQQPbSPd0T72h6QtHxjk8ncyUOimWDokIn7Y39iXjDFvAhhjio0xLcaYVuBp+rgruivGmELr3xLgLeyxFTu6c61/S9wX4RHOBNYYY4rBs4+tpbNj6ZGfZRG5FjgHuMpYA7StYRRl1u+rsY+BH+q+KO26eO899dj6AhcBixzbPOXYdvS9hZd9dhXgBe+NtpG9TtvIXuQtbaS3tY/guW2ku9rH/pC0rQIyRSTNupp0ObDYzTE5WWNxnwG2GmMed9nuOp71QmBT+/u6g4iEiMgAx+/YJ9luwn5Mr7V2uxZ4xz0RdqjNVRhPPbYuOjuWi4FrrEpDU4FKR1e7u4jIAuAe4DxjzCGX7bEi4mP9ng5kArnuifKwLt77xcDlIhIgImnY4/22r+PrwOnANmNMvmODJxzbzr638KLPrnLSNrIHaRvZJ7zme8ab2kgvbB/BA9tIt7aPxk3VV3ryB3tllh3Ys+373B1Pu9hmYO8G3QCss37OAv4NbLS2LwYS3B2rFW869ipC64HNjuMJRAOfAzutf6PcHasVVzBQBoS7bPOYY4u9oSwCmrBfbflBZ8cSexf6k9bneCMwyQNizcE+Ftvx2f2Hte/F1udjPbAGONdDjm2n7z1wn3VstwNnujtWa/vzwC3t9vWEY9vZ95ZHfnb156jvp7aRPRevtpE9G5+2kX0Xq0e2j53Fa233uDbSne2jWA+olFJKKaWUUsoD9YfhkUoppZRSSinVb2nSppRSSimllFIeTJM2pZRSSimllPJgmrQppZRSSimllAfTpE0ppZRSSimlPJgmbUoppZRSSinlwTRpU0oppZRSSikPpkmb6hdE5HkR+d8TfIxfisi/ejCmX4nIf3rq8dxFRIyIDHF3HEoppU6ctpfO56wRkfS+fE6lToQmbUpZjDG/Ncbc0BfPJSJzRKTVajSqRWS7iFzXF8+tlFJKnQg3tJf5HWz/r4gcdwzGmFBjTO6JRadU39GkTaluEBHfXnjYQmNMKBAG3AU8LSJZvfA83dJLr1EppdRJxNPbEk+PT6nOaNKmvJKIjBeRNVYv1SIgsN3t54jIOhE5KCJfi8gYl9vuEZEClx6uedZ25/AMEUm1hgX+QET2AV9Y26daj3dQRNaLyByXx00Tka+sx/0UiOnOazF2HwDlgGucw0TkUxEpt+K81OV5DoqIzfr7XyJS4nK//4jIj63frxORrVZMuSJys8t+c0Qk3zoe+4HnrO13i0iRiBSKyPXtjutZIrLFerwCEflZd16jUkop9+hP7eVRXueNIpJjtZmLRSTR5TYjIreKyE5gp8u2ISKSaI16cfwcEhFj7WMTkftFZK+IlIjIiyIS3u51Xysi+0TkgIjcd6KvQ6nOaNKmvI6I+ANvA/8GooDXgItdbp8APAvcDEQD/wQWi0iA2HuybgNOMcYMAM4A9nTxdLOB4cAZIpIEvA/8r/W8PwPeEJFYa9+FwGrsjc9vgGu7+XpsInKedb8ca1sI8Kn1mHHAFcD/ichIY8xuoAoYbz3ETKBGRIZbf88CvrJ+LwHOwd6bdx3wJ+v4OAy0Xstg4CYRWWC9rvlAJnB6u3CfAW62jt0orMZZKaWU5+lv7WUXr3Mu8DvgUiAB2Au80m63C4ApwAjXjcaYQmuoZKg1+uUtl/t+3/o5DUgHQoEn2j3uDCALmAc86NIWK9WjNGlT3mgq4Af82RjTZIx5HVjlcvuNwD+NMSuNMS3GmBeABut+LUAAMEJE/Iwxe4wxu7p4rl8ZY2qNMXXA94APjDEfGGNajTGfAtnAWSKSApwCPGCMaTDGLAHePcrrSBSRg0Ad9kbiJ8aYtdZt5wB7jDHPGWOajTFrgDeAS6zbvwJmi8hA6+/Xrb/TsCdo6wGMMe8bY3ZZvXlfAZ9gT/IcWoGHrJjrsDd4zxljNhljaoFftYu5yTp2YcaYCisupZRSnqlftZeuP9iTJYergGeNMWuMMQ3AvcA0EUl12ed3xphyK74Oicg9wDDAMcrkKuBxY0yuMabGetzLpe0Qy18bY+qMMeuxt71jj/JalDoumrQpb5QIFBhjjMu2vS6/DwZ+2u7LfRCQaIzJAX6MPRkpEZFXXIdQdCCv3eN+t4NGI8GKqcJKdDqKqSOFxpgI7EnWX4G57Z5rSrvnugp7zxjYk7Y52HvVlgD/xX6Vczaw1BjTCiAiZ4rICmu4yEHgLNoOQyk1xtS7/J3Y7jW3fw0XW4+x1xraMu0or1EppZT79Kv20vUHWNbudTofw0qwyoCkTuI7goicCdwJXOCS2LV5XOt3XyDeZdt+l98PYe+NU6rHadKmvFERkCQi4rItxeX3PODhdl/wwcaYlwGMMQuNMTOwNyoG+H0Xz+Xa0OUB/273uCHGmEesmCKtYY0dxdT5E9ivCt4DjBaRC1ye66t2zxVqjPmhdftX2HvM5li/LwOmY0/avgIQkQDsvXN/AOKtRu4DwPW4ub4+rNcxqLPXYIxZZYw5H/uQzbeBV7vzGpVSSrlFv2ovu1BoxQg4pxhEAwWdxNeGNRT0BeBSY4xrctfmca04m4HiE4xXqWOmSZvyRt9g/9K8Q0R8ReQiYLLL7U8Dt4jIFLELEZGzRWSAiGSJyFwroanHPjSxpZvP+x/gXBE5Q0R8RCRQ7MU8ko0xe7EP/fi1iPiLyAzg3O6+IGNMI/BH4EFr03vAUBG5WkT8rJ9THGPljTE7rdi/BywxxlRhb0Qu5vB8Nn/sQ1tKgWbrKuJ3jhLKq8D3RWSEiAQDDzlusF7XVSISboxpwj6vrrvHTimlVN/rd+1lJxYC14nIOCve3wIrjTF7jnZHEQkD3gHuN8Ysa3fzy8BdYi+cEmo97iJjTPMJxqvUMdOkTXkdK8G5CPvk4ArgMuBNl9uzsY/Tf8K6PcfaF+xJzCPAAexDGuKAX3bzefOA8639S7FfSbybw/+PrsQ+ybkce7Lz4jG+tGeBFBE51xhTjT3Buhz7lb792K9wBrjs/xVQZozZ5/K3AGuteKuBO7AnYhVWfIuP8ho/BP6MvcBIDkcWGrka2CMiVcAt2JNGpZRSHqgft5ftn+9z4AHso0uKgAzs7Wd3TMBeSORxcakiad32LPYiLkuA3diT19tPJFaljpe0HeaslFJKKaWUUsqTaE+bUkoppZRSSnkwTdqUUkoppZRSyoNp0qaUUkoppZRSHkyTNqWUUkoppZTyYJq0KaWUUkoppZQH83V3AAAxMTEmNTXV3WEopZTqA6tXrz5gjIl1dxzeQttIpZQ6OXTVPnpE0paamkp2dra7w1BKKdUHRGSvu2PwJtpGKqXUyaGr9lGHRyqllFJKKaWUB9OkTSmllFJKKaU8mCZtSimllFJKKeXBNGlTSimllFJKKQ+mSZtSSimllFJKeTBN2pRSSimllFLKg2nSppRS6qhKqxv4wfOr2FVa4+5QlFJKKY/yzLLdPPHFTlpbTa89hyZtSimljuoPH2/nqx2l7g5DKaWU8ihr91Xwuw+2srGgEpHeex5N2pRSSnVpY34lr67O47rpqWTEhro7HKWUUsojVNY1cfvLa4kPC+TRi8civZi1+fbaIyullPJ6xhh+/e5mokP8uX1eprvDUUoppTyCMYZ739xAUWU9r948jfBgv159Pu1pU0op1anF6wvJ3lvB3WdkERbYuw2SUkop5S1eWrmPDzbu52ffyWLi4Mhefz5N2pRSSnXoUGMzv/tgG6OSwrhk4iB3h6OUUkp5hK1FVfzPe1uYNTSWm2el98lz6vBIpZRSR6hrbOE3721hf1U9T1w5Hh9bL86uVkoppbzEocZmblu4hvAgPx6/dCy2PmofNWlTSinVRvaecm5/eS1FlfV8/9RUJqVGuTskpZRSyu2MMdz/1iZyD9Tynx9MISY0oM+eW5M2pZRSTqXVDfzwpTUE+/uw6KapTEmPdndISimllNu1thruf2cTb64t4MenZzJ9SEyfPr8mbUoppQB7g/STV9dRVdfEi9dPZnhCmLtDUkoppTzC/76/lYUr9/GjORnc6YZqylqIRCmlFAD/XJLL0p0HePDcEZqwKaWUUpZVe8p5dvlurpk2mLvPyOrV9dg6o0mbUkopVu+t4A+fbOfs0QlcOTnF3eEopZRSHqG+qYV73thAcmQQvzhzmFsSNtCkTSmlTnpLd5Zyy39WkxgRyO8uHu22BskbicizIlIiIptcti0SkXXWzx4RWWdtTxWROpfb/uG+yJVSSh2NMYYH39lEbmktD184mmB/980s0zltSil1Envii5384ZMdZMSG8H9XTdQFtI/d88ATwIuODcaYyxy/i8gfgUqX/XcZY8b1WXRKKaWOizGGxz7ezqvZ+dw+dwizh8a6NZ6jJm0i8ixwDlBijBllbVsEZFm7RAAHjTHjRCQV2Apst25bYYy5paeDVkopdeI25lfy+Kc7OGdMAn/47lgC/XzcHZLXMcYssdq+I4i9y/JSYG5fxqSUUurE5JTU8NDiTSzPKeOKyYP4yfyh7g6pWz1tz6NXEZVSqt8orqqnudVw71sbiA4N4OELR2vC1jtmAsXGmJ0u29JEZC1QBdxvjFnqntCUUkp1ZF3eQa56egU+NuHX543ke1MHe8S0gaMmbXoVUSml+o+FK/fxy7c2Ov9+8soJhAfpkMhecgXwssvfRUCKMaZMRCYCb4vISGNMVfs7ishNwE0AKSlaGEYppfrClsIqrnlmJdGhAbx68zQGhge6OySnE53TplcRlVLKS7y1Np/73t7I7KGxnDlqIEH+Ppw1eqC7w+qXRMQXuAiY6NhmjGkAGqzfV4vILmAokN3+/saYp4CnACZNmmT6ImallDqZ5ZTUcPUzKwkN8OWlG6Z4VMIGJ5606VVEpZTyAnnlh7jnjY1MTYvmn1dP1OGQve90YJsxJt+xQURigXJjTIuIpAOZQK67AlRKKWW3t6yW7/1rJSLCf26YwqCoYHeHdITjLvnvchVxkWObMabBGFNm/b4acFxFPIIx5iljzCRjzKTYWPdWY1FKqf7ukY+2YRN4/DItONKTRORl4BsgS0TyReQH1k2X0/aiJsAsYIOIrAdeB24xxpT3XbRKKaXayy2t4bJ/rqChuYX/3DCZ9NhQd4fUoRPpadOriEop5cHW5x3k0Y+3kR4TyvsbirhzXiYJ4UHuDqtfMcZc0cn273ew7Q3gjd6OSSmlVPfklR/i8qdW0NJqePmmqQwbGObukDrVnZL/LwNzgBgRyQceMsY8Q+dXEf9HRJqBFvQqolJKuUVLq+GXb20kt7SWb3aVkRgeyM2z090dllJKKeURquqb+MELq6hvauH1H57K0PgB7g6pS92pHqlXEZVSysu8sSafzYVV/OXycczJigMDwf4nOo1ZKaWU8n7GGH78yjpyS2t54frJHp+wwYkXIlFKKeVhDjU289jH2xmfEsF5YxM9Yn0ZpZRSylO8+M1evthWwq/PG8n0ITHuDqdbjrsQiVJKKc/05poCSqsb+MWCYZqwKaWUUi52Flfz2w+2clpWLNdMG+zucLpNkzallOpHjDE8//UeRieFMzktyt3hKKWUUh7jQE0DN7yYTWiAL7+/ZIxXXdjUpE0ppfqRpTsPkFNSw3XTU72qMVJKKaV6U21DM9c/v4riqnqeumYScQM8a/Hso9GkTSml+pF/LdtNTGgAZ49JcHcoSimllEcwxnDvmxvZVFDJE1dMYOLgSHeHdMw0aVNKqX7i0y3FLNlRyo0z0wjw1QW0lVJKKYCXVu5j8fpCfjJ/KKePiHd3OMdFq0cqpZQXK6mu59/f7OWU1CgefGcTWfEDuH5GmrvDUkoppTzChxuL+PW7m5mTFcuP5gxxdzjHTZM2pZTyUq2thrsWrWN5ThkAIvDElRPw89FBFEoppdTrq/P5+evrGTcogr9cNh6bzXvnemt0ZqnzAAAgAElEQVTSppRSXuqZZbtZnlPGr88bSWSIPzbBK8fpK6WUUj1tXd5B7n1zA6dmxPDUNRMJ9vfutMe7o1dKqZPQexsKeXpJLuvzKzljZDzXTBuslSKVUkopS1V9E7e/vIa4AYE8eeUEr0/YQJM2pZTyKmv2VXDnK+vIiA3hngXDNGFTSimlXBxqbObmF1dTeLCeV2+eRniwn7tD6hGatCmllJeobWjmrkXrGBgWyOs/PJWwwP7RECmllFI94VBjM9c9t4pVe8r546Vj+9WUAU3alFLKS/z1853sKz/EKzdO1YRNKaWUclHb0Mx1z68ie085f7psHOePS3J3SD1KkzallPICVfVNvLRyH+eOSWRKerS7w1FKKaU8RkNzizNh+/Pl4zlvbKK7Q+pxmrQppZQXWPRtHjUNzdw4M93doSillFIe5eH3t/Lt7nL+cvm4fpmwAehiPkop5eGaWlp5bvlupqRFMTo53N3hKKWUUh7jrbX5vPjNXm6YkdbvhkS60qRNKaU8lDGG7D3lXPbPbyisrOemWdrL5mlE5FkRKRGRTS7bfiUiBSKyzvo5y+W2e0UkR0S2i8gZ7olaKaW8nzGGfy3N5aevrmdyWhT3nDnM3SH1Kh0eqZRSHuhfS3N5ZtluiirriQkN4LFLxjB3WJy7w1JHeh54Anix3fY/GWP+4LpBREYAlwMjgUTgMxEZaoxp6YtAlVKqvyipquehxZv5cNN+zhw1kMcvHYefT//uizpq0iYizwLnACXGmFHWtl8BNwKl1m6/NMZ8YN12L/ADoAW4wxjzcS/ErZRS/dYzy3bzv+9v5dSMaH58eiZnj0kkNECvsXkiY8wSEUnt5u7nA68YYxqA3SKSA0wGvuml8JRSqt9ZsqOUWxeuoaG5lbvPyOKHszOw2fr/eqXdOQt4Hr2KqJRSvc4Yw39W7OU3721hwciBPHnVBHxOgoaon7pNRK4BsoGfGmMqgCRghcs++dY2pZRSR2GM4bXV+fzyzY1kxg/g/66aQFpMiLvD6jNH7Uc0xiwByrv5eM6riMaY3YDjKqJSSqlONLe0sj7vID99bT0PvLOZ07Ji+fPl4zRh815/BzKAcUAR8Edre0dvqOnoAUTkJhHJFpHs0tLSjnZRSqmTxq7SGq559lt+/voGpqRH8erNU0+qhA1ObE6bXkVUSqkTdPBQI+c/uZy9ZYcQgTvnZXLHvExN2LyYMabY8buIPA28Z/2ZDwxy2TUZKOzkMZ4CngKYNGlSh4mdUkr1dw3NLfzjv7k8+WUOAb42Hjp3BFdPHYxvP5+/1pHjTdr+DvwG+xXC32C/ing9x3gVEbgJICUl5TjDUEop7/brd7dQUFHHY5eMYfbQWOLCAt0dkjpBIpJgjCmy/rwQcFSWXAwsFJHHsU8hyAS+dUOISinl8VbtKefeNzeSU1LDOWMSePDcEcQNOHnbyONK2vQqolJKHRtjDCJtr2u9t6GQt9YWcOe8TL47aVAn91SeTEReBuYAMSKSDzwEzBGRcdgvWu4BbgYwxmwWkVeBLUAzcKvO+VZKqbaMMTyzbDcPf7CVxPAgnvv+KZym1ZOPL2nTq4hKKdV9W4uquPHFbManRPKH746hpKqB33+0jfc2FDEyMYxbTxvi7hDVcTLGXNHB5me62P9h4OHei0gppbxXbUMzD3+wlYUr93HmqIH84btjCdHqyUD3Sv7rVUSllDpO3+4u5wfPr8LHR3h3fSE79lezu6wWm8Ad8zK5eVY6/r4n39h8pZRSyqGmoZmPNu3nT5/uoOBgHTfPTueeM4adFKX8u+uoSZteRVRKqeNjjOH+tzcSGeLPKzdNZUVuGb98ayPnjE7g7gVZJIQHuTtEpZRSym2+3F7C66vz+WxLMQ3NrQyND+X1W6YxKTXK3aF5HO1vVEqpXrJ6bwU7imv43UWjSYwI4qIJyZw/LkkrQyqllDrpPb0kl4c/2EpUiD+XThrEBeMTmZASecT8b2WnSZtSSvWgllbDm2vymTU0loUr9xEa4Mt5YxOdt2vCppRS6mS3cOU+Hv5gK2eNHshfLh+P30lYwv9YadKmlFI96N31hdz9+gaiQ/ypbmjmuxOTdRK1UkopBZTXNvLgO5t4b0MRMzNj+NNl4zRh6yY9k1BKqR7S0mr46xc7SY8NwUeEstpGrpyi61AqpZRSH23az/1vb6Syromfzh/KLXMyNGE7Bpq0KaXUcappaOaZpbv5bGsxrcYwOS2K3NJa/u+qCczJimXPgUOMSAxzd5hKKaWUWzQ0t7CzuIbHP93BF9tKGJkYxr9/MIXhCdo2HitN2pRS6jgYY/jxK+v4fFsxE1IiqTjUyHPL9zA0PpQFIwdis4kmbEoppU5K+yvruf3lNazaUwHAgEBffnnWMK6bnqa9a8dJkzallDoOTy3J5bOtxTx07gium55GU0sr720oZHhCmK4ro5RS6qTU2mr4bGsx9729iUMNzdwxdwjJkcGcPiKeqBB/d4fn1TRpU0qpY/TG6nx+/9E2zh6dwPdPTQXAz8fGheOT3RuYUkop5QaHGpt5Y00Bzy7bze4DtaTFhPDSDVMYGj/A3aH1G5q0KaVUN7W2Gp5emsvvPtzG9CHRPHrJGF1PRiml1ElnU0El764vZPeBWvaU1bK37BANza2MTQ7nb1eMZ8GogToMsodp0qaUUu0s23mAyromZmfF8uyy3by2Oo8xSREUV9WTvbeCBSMH8ufLxxHo5+PuUJVSSqleV13fRE5JDTklNSzdeYDF6wvx97UxOCqY1JgQZg+NZf6IgZySqotj9xZN2pRSJ6W88kM8s2w3728sYsaQGH5zwSh8RPj9R9t4/us9ANgEWg1MSYvi2z3lNLe08ofvjuXiCUnaKCmllOq3jDEsXl/Ia9n57CyppriqwXlboJ+NW2Zn8KPTMggL9HNjlCcXTdqUUiedfWWHuOjvy6mqa2ZqRjTvrCtg6c5SquqaaWxp5YYZaczOiuXzrSXMGBLD6SPiaW01AFpkRCmlVL9V39TCJ1uKeXbZbtblHSQ9NoTpQ2IYEhfKkNhQMuMHMCgyCF8d+tjnNGlTSvUbjc2tfLipiKnp0cSHBbL7QC2+NmFQVLBzn7zyQ1z73Lc0txo+uHMmQ+JCWZlbxtNLc0mPDeX04fFMTosCYGZmrPN+mqwppZTydsYYWloNB2oayas4RF75IfLK68irOMTOkhq2FVXR0NxKUkQQj14yhksmJGv75yE0aVNKeaUVuWV8ua2EW2ZnEBniT3FVPT96aQ2r91bg72NjWMIANuRX4ucj3HvmcGIHBPBqdh7Lcg7g72Nj4Y1TGBIXCsCU9GimpEe7+RUppZRSPaO11bClqIrlOQfYkF/J9uJqiivrqW5o7nD/uAEBpMWEcPXUwczJiuPUjGhN1jyMJm1KKa/S0NzCz17bwLvrCwF4f2MRC0YOZFF2Hi2thocvHMXWoirW7jvI3WdksXZfBf/z3hYAkiKCuH1uJt+dmNym900ppZTqD5btPMCr2XkszzlAWW0jAMmRQQxPCGPGkBjCgvzwtQlRIf4kRwYxKCqYpIggLazlBTRpU0p5lb98tpN31xdy57xMpmVEc9eidTyzfDdnjhrIT+ZnOXvPHIwxfLy5mNAAX71yqJRSql8prW5gzb4KcktrWZ5zgGU5B4gO8WfW0FhmZsYwY0gMcWGB7g5T9QBN2pRSHqmqvolvc8vZkH+QA7WNhPj7kDUwjH98tYvLJg3irvlDAfjox7Oorm8iObLjnjMRYcGogX0ZujqJiMizwDlAiTFmlLXtMeBcoBHYBVxnjDkoIqnAVmC7dfcVxphb+jxopZTX21RQya8WbyZ7b4Vz28CwQO4/ezhXTxtMgK/2nPU3mrQppTzClsIq1ucfZP6IeD7ZXMxv3ttCXVMLNoHIYH+qG5ppbG4lMTyQ+84Z7rxfeJAf4UFacli5zfPAE8CLLts+Be41xjSLyO+Be4F7rNt2GWPG9W2ISilv19DcwqvZ+byWnUdlXRN55YeICvHn5wuymJIWzdD/b+++o+Oq7rWPf7d678WyimXZcsdVLjRDMM10EiB0CAZDAgkk3NwQEgjhkrwhjSSXUBwg9F6CKTf0koBtLFdsy1WWLVmyuqw+0szs9w+NFdnINJUzIz2ftbRmZuuM9OjMeLZ/++yzT3oMsVp+f0j7wqJNo4giMlCstdS3dvLKunJ+9VoRHR4vN7/0KdbCUWNTuPYbY5mRk0BEaDCN7Z28t7mKCSPidF0Y8RvW2g99fV/Ptjd7PFwOnDOYmUQkcHm9lq1VTeyoaqGktoWdNS2U1LSwraqZfW2dTM2KZ3p2AmdMG8mVR+dp0HIY+TJH2h5Go4gi0gcer2VdWQOuTi9xkSFMHBHHRztq+Mnz6ynf1w7AseNT+cGCfN7eVElmYiQXzM454PyzuIhQzpye6dSfIPJ1XQE80+PxaGPMGqAR+Lm19l/OxBIRJ1hrqW52UVLTSlN7Jy0dHto63FQ2utha2cTy4lpqmju6t0+LDSc3JZqTJ4/glKkZzM9PwRidmz0cfWHRplFEETmUmmYX9S0d5KfH8u7mSm59eSNzRyczLy+JD7fV0NjWydi0GN7dXMXOmpbu56XEhFHT3EF+Wgw/P3UiY9JiOCY/laAgw8ycRAf/IpH+Y4z5GeAGnvA1VQA51tpaY8ws4B/GmMnW2sZenrsYWAyQk5MzWJFFZAA0tHbw5sZK3t9axSc76w4oynrKSozkyLEpzM9PZUJGLLnJ0USH60wm6dIf7wSNIooMQ50eLxc/sILNe5soGJXI6t31ZCdF8c8NFbywuozk6DBSY8P5aHsNk0fG8advTyc9LoLyhjbe31rNyIQIfnj8OC0zLEOSMeYyuk4tWGCttQDWWhfg8t1fZYzZAYwDCg9+vrV2CbAEoKCgwA5WbhHpu4p9bWytbKa0rpW3NlXy0fYa3F7LyPgI5uenclhWPHmpMSREhhIVFkxkWDBJ0WFEhalAk0Pr07tDo4giQ1NhSR3bqpoJCTKcPSOTkOAg2js9VDe58HgtOUlRPPxRCZv3NnHOrCze21zFiZNG8MdvT8PjteyqbWViRhzBQQaP1xJ80DL735qV5dBfJjLwjDEn03XKwDHW2tYe7alAnbXWY4zJA/KBYodiikg/ae/0sK2ymcJddby5sZJlxbXd38tOiuTKo/M49bAMpmTGaWqjfG1fu2jTKKLI0HT3u9v4/Ztbux9vr2rmwrk5XLBkeff5ZzlJUdQ0uzhuQhq/O2cqwAEd0ZTM+O77BxdsIkOJMeYp4FggxRhTBvyCrvO8w4G3fP8u9i/KNR+43RjjBjzANdbaOkeCi8hX4nJ72FHVQk2zi7qWDmpbOthc0ciqXfWU1Lbg9f1PdnRKNDeeMI55Y5JJj40gOylShZr0i69VtGkUUSRweb32MxeYLq5u5vVPK9hS2cwr68o5e0Ym/33yeO5+dzv3f1jMc6vKsNby67MPw2J5dV0FrR1ufnnGZHVGMqxZay/opfnBQ2z7AvDCwCYSkb7wei2dXi9VjS7WljawZncDa0rr2binkQ6P94BtE6NCmTUqidOmjWRcegwzcxIZmRDpUHIZ6r7Mkv8aRRQJYBv27OPaJ1cTFxFKSLChqKKRqVkJLLlkFglRYbyxcS8/emYtLR0e4iJCuOzwUdx6+mSCgwy/OH0yW/Y2saWyiaeumtd9BO2iuaMc/qtERET6pr3Tw/OrylhX2kCzy01xdQvbq5vxeP8zASw8JIipWfFcfmQuh2XGMyI+gqToMJKjw4iPDNXApQwa45vZ6KiCggJbWPiZGZQi8iXsrm3llfXlrN5Vz49OHMekjDjueX8H7Z0evnfsWM7660fUtriYNDIeV6eH0SnRvLh6D7kpUSRGhbFiZx3TsuK59+JZvY4Qdri9tHa4SYgKc+Cvk6HIGLPKWlvgdI5AoT5SpH80tXeyZW8TRRWNfLpnH+9tqaa6yUVabDhxkaGMSooiPz2W2IgQ4iNDmZ6dwPgRsYQGBzkdXYaJz+sftUyNSICpaXbx5sZKcpOj+Nf2Gv72YTFuryUqLJiLHljBggnpvLC6DIDnV5VRsa+dBy8rYMHE9O6fcerUDK55bBWdHsuPTxrPoqNGH3IVx7CQIMJCVLCJiEjg2VrZxMMfl/Dh1mrK6tu627umNiay6Kg85uUl6YiZ+D0VbSIBpKm9s3uZ/f3OnZXFDSeMw+OxfHvJMl5YXcalh49iwog4bnl5A9+ckXlAwQZwdH4qq245gfCQIHVUIiIS8GqbXXy0o5Z3iyopq2+j2eWmvKGNxnY34SFBLJiYxgVzcpgwIpYJGXGMjI9Q/ycBRUWbiB/b09BGi8vNuPRYml1uvvfEarZXNXPfxTOJCO26rsvUrITu7Z+75nBWltRx1vRMjDF8Y0IqqTHhvf5sXR9NREQCVYvLzSclXUvsf7i1mj0NXUfRkqPDGJceS3ZSFHNGJ5GXEs0Z0zNJitaMEQlsKtpE/EyH20tRRSMvry3nseUldHosx09MY1N5IxWN7dz5ramcPCWj1+dmJUaRlRjV/TgjXqtYiYjI0OD1Wt7fWsVD/y5heXEtbq8lOiyY+eNSufyIXGaOSmB6dqIuNSNDkoo2ET9SWFLHlY8W0tDaSZCB8wqyyYiPZMmHO8hMjOT5C49g1qhEp2OKiIgMKK/XsqehjW1VTWytbGbDnn18vKOWupYOMuIjuGp+HvPykpk7OkkzR2RYUNEm4rAPt1azrrSB+KhQ7vy/zaTHRXDHWVMoGJXEiPgIAK79xhiCg4zm34uIyJBhraXJ5aaq0UV1k4uqpnaqm1xs3tvE+1uqqGnu6N52RFwEx45L5biJaZw0eYRWdJRhR0WbyABo7/TwTlEVo5Kjuq9ttr2qiZtf3EBEWDC3njaRqkYX939YzAdbq7ufl5cSzVOL55EeF3HAzwtR5yQiIgHM47UUVzezenc9/9pWw/qyfVQ1tdPe6f3MtvGRoRw7PpW5o5MZlx5Dflos8VGhDqQW8R8q2kT6UXWTi2cLS3n44xKqm1wAjE2LIT4ylE/37CM6LBi313L8Hz8Eujqmn586kfNmZ1PR0E5OUhSRYZrmISIigclaS2N718qNJTUtrCvbx7rSBj7ds49mlxuAtNhwZo9OYmR8OmmxEaTGhpMWG05aXDipMRHERYZoZonIQVS0iXwNK4pr2VrZRF5qDGNSYwgKgrve2sZzhaW4vZajxqbwu3OmsruulbeLqvB6Ld+ckcmNJ44H4PHlu8hLjeakySO65+LHjdAoooiI+K/2Tg9l9a3srmtld20ru+vaqGxqBwtNLjcVDW2UN7TR0uHpfk5osGFSRhzfnJnJtKwEpmUnMCY1WkWZyFekok0EcHu8VDW5aGjtZFx6TPd0xA179vGLpRuJDA3m7BmZxEeG8nZRJU+vLP3MzwgJMlw4N4fLjshlTGpMd/ulh+d+ZtsfnjBuwP4WERGRvnK5PWwqb2RtaQNrSxtYV9pASW3rAdtEhgaTER9BUJAhMjSYvNRojspPITMhkoz4SLKTIhk/IpbwEM0gEekrFW0yrJTVt7JsRy1tnR4iQoLJToqiqKKRe97f3n3Cc2ZCJKdNzaCqycWr68tJjAojLCSIG59bB0CQgauPyePiuaMorWtlR3Uz1U0uzpqRSV6PYk1ERMSftXV4WFvaQGldKxX72tnb2M7efW1U7GunuLqFDk/X+WbpceFMz07g7BlZ5KZEkZ0URXZiFCkxYTpiJjJIVLTJkPfGxr08tmwXO2taui++ebDD85K58cSRhAYH8fyqUu7/sJj0uHBOnzqSW06bRHxkKJsqGvFaS2psePf1z7KTojhibMpg/jkiIiJficvtoaG1k4p97RSW1LGubB/F1c1srWyi02O7t0uJCSM9LoKsxEjmj0tlRnYC03MSdM1PET+gok0ChrUWt9cSGhxEZWM71z6xmlmjErnxxPGEhXx2dcVOj5eHPyrhV68XMTolmoLcRL6Tmcsx41JJiAqjrcPDrroWosKCmTUqqft558zKwu3xfmbFxv2rQIqIiPiTfa2dLF23h+KaFupbOqhv7aS+tYO6lg7qWzoOOMcMumaUjE2L4ej8VObmJTE2NYa0uHBNYxTxYyraxO9VNrbz239u4YOt1TS1d3Ll0aN5Y2Mlu2tbKdxVz9tFlUSEBlPd5CIkyBAcbAgyhvKGNjo9llMOG8Efz5ve68U3c5Kjev2dWmJfRET8XV1LB39+eytPryzF5fYSGx5CYnQYiVGhJEWHMSY1hsSoMJKiQ0mICiMlJpwZOQmfuayMiPg/FW3iNzo9XkIOuoB0YUkd331iNc3tbk6cnE6nx8tf39tBRGgQjy2aw762Tv763nYSo8OYMjIej7V4vF1H5BZOyeCwzHgWThlBUJDm3IuISOBrbO/k4+21fLC1mtfWl9PS4eGcmVlcdkQuk0bGOR1PRAaIijZxjLUWl9tLaHAQf35nG3e/u41p2QlcMDsHDLy1qZK3NlUyKjmKxxfNZfyIWADWlzUQHGSYPLJruuKJk0c4+WeIiIgMqB3Vzfxzw14+2FrN6l31uL2W2PAQ5o9P5foF+YxLj3U6oogMMBVt4oj2Tg9XP7aKD7ZWExsRQlO7mxMmpbNlbxP//cJ6oOvC0zccn88VR40mLuI/1zCbmpXgVGwRkQMYYx4CTgOqrLVTfG1JwDNALlACnGetrTdd0wj+DJwCtAKXW2tXO5Fb/J/L7eGNjZU8uWIXy4vrAJiSGcfVx+RxzLg0ZuQkEKqp/CLDhoo2GXQdbi/fe2I1H26r5vIjcmntcHPk2BTOnJ6J2+NlZ00LEaHBpMaG93oemoiIH3kYuBt4tEfbTcA71trfGGNu8j3+CbAQyPd9zQXu9d2KHOCTnXVc9+RqqppcZCdF8uOTxnPurCzSdC6ayLD1pYo2jSRKXz2+fBejkqM4Oj+VJR/u4N3NVdxx1hQunjfqgO1CgoPI1zQPEQkQ1toPjTG5BzWfCRzru/8I8D5dRduZwKPWWgssN8YkGGMyrLUVg5NW/J21lsdX7OaXSzeSkxTFb8+Zyvz8VJ2XLSJ82ePqDwMnH9S2fyQxH3jH9xgOHElcTNdIogxjf/9oJz//xwa++/hq1pc1cN8HxZw4Kf0zBZuIyBCRvr8Q892m+dozgdIe25X52mSY6/R42bK3ie8+vppb/rGBo/JTeOnaIzl2fJoKNhEBvuSRNo0kytf1TlElt7+6iaPzU1i9q55z71uG22v575MnOB1NRGSw9fa/b9tLG8aYxXQNfJKTkzOQmcQhHq9lY/k+Hl22i6XryulwewkNNtx8ygSuPCpPxZqIHKAv57QdMJJojPmikUQVbcNMZWM7Nz63jkkZcdx/ySz+saacm1/6lAvn5jA2LcbpeCIiA6Vy/2ClMSYDqPK1lwHZPbbLAsp7+wHW2iXAEoCCgoJeCzsJPM0uN0vXlvPGxr0UltTR0uEhMjSYc2ZlMSc3iVmjEslO6v36oSIyvA3EQiRfaiRRo4hDU6fHy6pd9QD89b3tuDq9/OWCGUSFhXDBnGxGxIczLy/Z4ZQiIgNqKXAZ8Bvf7cs92q8zxjxN1wIk+zQLZfhYV9rA959aw+66VkYlR/GtWVlMy0pgwcQ0EqLCnI4nIn6uL0Vbn0YSNYo49Dzwr2Lu+2AHNc0d3W2/PvswxqR2HVUzxnDchHSn4omI9DtjzFN0nSqQYowpA35BV7H2rDFmEbAbONe3+et0LdK1na6Fur4z6IFlULW43Hy8o5YXV5fx1qZK0uMieOqqeczLS6Jr3TYRkS+nL0WbRhKl28tr93DHa0UcNTaFi+flEBcRSlhIELNGJTodTURkwFhrLzjEtxb0sq0Frh3YROIPiqub+f2bW3hrUyWdHktydBjfOTKX676RT3xU6Bf/ABGRg3zZJf81kiifsXRdOb95vYgxaTGsLKljTm4Sf//ObF3sU0REhp09DW28t7mK97dU8f6WasJDgrjs8FyOHZ/GnNFJhIWobxSRr+/Lrh6pkcRhqqiikcKSOk6YNIIR8V0X9fR6Lc+vKuOmF9czLj2WPfVtpMaGc/dFM1SwiYjIsFHT7OKFVWX8Y205RRWNAGQlRnLZEblcc8wYUmPDHU4oIkPFQCxEIkOAy+3h0gc/YcXOOgB+9XoRpx42EmstK3bWsaehjSPGJPPAZQVEheltJCIiw4e1lmcLS7njtSKa2t3MyEng5lMmcNyENMakxuh8NRHpd/rftvTq3vd3sGJnHT85eQJH56fwwL+KeWdzJdFhIYxLj+HHJ43nlMMyNN1DRESGld21rfz0pfV8tL2WOaOTuOOsKYxLj3U6logMcSra5DN2VDdzz3s7OH3aSL577BgA/nT+DIdTiYiIOMfjtTz8cQm/f2MLwUGGO86awoVzcnQRbBEZFCrahrFml5tLH1zB9qpm0uIi+NkpE5mVm8j1T68hIjSIW06b6HREERERx7R3etiyt4l/b69h6dpytlQ2cdyENH519hQy4iOdjiciw4iKtmHstqUbWVPawPmzs1m9q4ErHy1kdEo0u2pbuP+SWaTFRjgdUUREZNC5PV7+/M427v+gmA6PF4AZOQn85YIZnD41Q+esicigU9E2TL26vpznV5Xx/ePGcuOJ42l2ufnu46v4aHsNd184UxfBFhGRYamqqZ1rn1jNypJ6zpg2koVTRjAjJ7F7BWURESeoaBuG2jo83P7KJqZmxXP9gnwAYsJD+Pvls6lp7lDHJCIiw9L6sgaufmwVDa2d/Pn86Zw5PdPpSCIigIq2YenvH++kqsnF3RfOJKTHddVCgoNUsImIyLCzenc9f3p7Gx9urWZkfATPf/dwJo+MdzqWiEg3FW3DQLPLjQGiw0PYVdvCve/vYMGENOaMTnI6moiIiGPaOz384c0tPPDvnaTEhPOjE8ZxybxRJEaHOcoiCaAAABjwSURBVB1NROQAKtqGsMrGdu5+dzvPFpbicntJjQ2nuslFWHAQPz55vNPxREREHLN6dz3/9dw6iqtbuHBuDjefMpGYcP23SET8kz6dhqiKfW2ce98yKhvbOXtGJtmJUeysbWFSRhwnTEpnVHK00xFFREQcsXRdOT98Zi3pseE8tmgOR+enOh1JRORzqWgbgupbOrj4gRU0tHby/DVHMC07welIIiIifuHJFbv52T8+ZXZuEg9cVkBcRKjTkUREvpCKtiHo9lc3sbuulccWzVXBJiIiQtf5a7ct3cjTK0s5Zlwq9108i8iwYKdjiYh8KSrahohX15fT6vKQGhfOS2v28P3jxjIvL9npWCIiIo5r7/Rw5SOF/Ht7Ddd+Yww/OmE8wUG6QLaIBA4VbUNAY3sn//XcOto7vQDkJkdx7TfGOpxKRETEeZ0eLz94ag3/3l7D786ZyrkF2U5HEhH5ylS0DQGvrqugvdPLzadMYHlxHd87dgwRoZryISIiw1tVYzvXPbmGT0rq+MXpk1SwiUjAUtE2BDxTWMr49FiuOjqPxfPHOB1HRGTYM8aMB57p0ZQH3AokAFcB1b72m621rw9yvGGhvKGNb97zMfvaOvnz+dM5c3qm05FERL42FW0ByFrLlsomNuxpJDwkiHWlDfz81IkYo/n5IiL+wFq7BZgOYIwJBvYALwHfAe6y1v7ewXhDXovLzaJHCmlxuXnumsOZkhnvdCQRkT752kWbRhGdUd3k4oK/LWd7VXN3W2iw4ewZGkEUEfFTC4Ad1tpdGlwbeNsqm/jpi5+yZW8jD10+WwWbiAwJX7to0yji4PN4LT94ag2lda38+uzDKMhNZFdtK9FhwSTHhDsdT0REenc+8FSPx9cZYy4FCoEbrbX1zsQaeh5dVsLtr2wiKiyYu749nWPHpzkdSUSkX/TX9EiNIg4wl9vDHa8Wsay49oDVr8alxzqcTEREDsUYEwacAfzU13Qv8D+A9d3+Abiil+ctBhYD5OTkDErWQPfoshJufXkjx09M485vTdVgpogMKUH99HN6G0Vcb4x5yBiT2E+/Y9jaVN7Iwj/9i8eW7+I7R+Zq9SsRkcCxEFhtra0EsNZWWms91lov8DdgTm9PstYusdYWWGsLUlNTBzFu4Gnv9HD7K5u6C7Z7Lpqlgk1Ehpw+F209RhGf8zXdC4yha+pkBV2jiL09b7ExptAYU1hdXd3bJkLXydTXPL6KZpebR66Ywy9On+x0JBER+fIuoMegpjEmo8f3zgY2DHqiIaS1w805933MQx/t5NLDR/HXi2YSFtJf49EiIv6jP6ZHfmYUcf83jDF/A17t7UnW2iXAEoCCggLbDzmGpDteK6K0vpWnr5rH3Lxkp+OIiMiXZIyJAk4Aru7R/FtjzHS6pkeWHPQ9+Qqstfz8pQ1sLG/kvotncfKUEU5HEhEZMP1RtH1mFNFaW+F7qFHEPlizu56nPtnN1fPzVLCJiAQYa20rkHxQ2yUOxRlyni0s5cU1e/jh8eNUsInIkNenok2jiAPruVVlRIYG84MF+U5HERER8Rt7Gtq4/ZVNHDEmmeuOG+t0HBGRAdenok2jiAPH5fbw2voKTpqcTnS4roEuIiICXdMif/bSp1jgzm9NJThIq1aLyNCns3X91Hubq9jX1snZM7OcjiIiIuI3nllZyvtbqvmvE8eTnRTldBwRkUGhos1PvbRmDykx4Rw5RueyiYiIAHy8o4ZbXt7AUWNTuOyIXKfjiIgMGhVtfuj/Pq3g7aIqzpo+kpBgvUQiIiLrShu45rFV5CZH89eLZmpapIgMKzpZyk+s2V3P/R8UExsRwktr9jA9O4Hrj9cCJCIiIu9truJ7T6wmJTaMhy6fTXxkqNORREQGlYo2P3HnPzeztrSBsOAgDh+TzD0XzSQ2Qp2SiIgMb0UVjVz9+CrGpcfw98vnkBob7nQkEZFBp6LND2ws38fy4jp+unACVx8zxuk4IiIifqG1w811T64mITKUh78zh5QYFWwiMjypaPMDD/57J1FhwZw/J8fpKCIiIn7jtqUbKa5p4YlFc1WwiciwplUuHPbx9hpeWVfOeQXZmqMvIiLi8/LaPTxbWMa1x47liLEpTscREXGUjrQ56PZXNvHQRzvJTY5i8fw8p+OIiIj4hZ01LfzspQ0UjErkBi3KJSKios0pq3bV89BHOzl/dja3nTGZiNBgpyOJiIg4bk9DGxc/sIKwkCD+fMEMXfpGRARNjxx01loA/vredhKjQrn19Ekq2ERERICqpnYufmAFje2dPHrFHDITIp2OJCLiF3SkbRC9vHYPN7/4Kd+cmcW7m6u48YRxRIXpJRAREalv6eCSBz6hsrGdxxbNYUpmvNORRET8hiqGQWKt5d73dwDw2PJdxIaHcOkRuc6GEhER8QON7Z1c+tAn7Kxt4eHLZzNrVJLTkURE/IqKtkGysqSezXubuPNbhzEmNQZj0GqRIiIy7LV2uFn08EqKKhpZcuksrRQpItILFW0DpNnlZmVJHRUN7WQlRvL0yt3ERYRwxrRMIsN0DpuIiMiGPfv48fPr2bK3kf+9YCbHTUh3OpKIiF9S0TZAbnphPa+urzigbdFRo1WwiYjIsOf1Wu79YAd/fGsrSdFh/O3SAhZMVMEmInIoKtoGQIvLzdtFlXxzRiY/OnEcW/Y28UlJHVcepWuxiYgMF8aYEqAJ8ABua22BMSYJeAbIBUqA86y19U5ldEKnx8s1j63inc1VnDY1g1+ddRjxUTpdQETk86hoGwDvbq6ivdPLt2dnk5UYRVZilEYQRUSGp29Ya2t6PL4JeMda+xtjzE2+xz9xJpoznli+i3c2V3HLaZO44shcjDFORxIR8Xt9vk6bMabEGPOpMWatMabQ15ZkjHnLGLPNd5vY96iB47X1FaTFhlOQq9WvRETkAGcCj/juPwKc5WCWQdfQ2sFdb2/jqLEpKthERL6C/rq49jestdOttQW+x/tHEvOBd3yPh4Vml5v3tlRxymEZBAepMxIRGcYs8KYxZpUxZrGvLd1aWwHgu01zLJ0D/vT2NpraO/n5aRNVsImIfAUDNT3yTOBY3/1HgPcZgtM/Oj1eXG4vMeH/2Y3PFZbicns55bAMB5OJiIgfONJaW26MSQPeMsZs/rJP9BV5iwFycnIGKt+geqeokoc/LuHSw0cxYUSc03FERAJKfxxpG7Yjib9YupHjfv8++9o6Adiyt4nf/N9m5o9LZXbusJoRKiIiB7HWlvtuq4CXgDlApTEmA8B3W3WI5y6x1hZYawtSU1MHK/KA2VXbwg+fWcuUzDhuPmWi03FERAJOfxRtR1prZwILgWuNMfO/zJOMMYuNMYXGmMLq6up+iDG49u5r57nCUqqaXNz11lbqWjq47snVxEaE8odzp2nah4jIMGaMiTbGxO6/D5wIbACWApf5NrsMeNmZhINnfVkD5963DGMM9140i4hQXfpGROSr6vP0yJ4jicaYA0YSrbUVhxpJtNYuAZYAFBQU2L7mGGx//2gnHq/lhEnpPLqshLc2VVLd7OLvl88mNTbc6XgiIuKsdOAl3wBeCPCktfafxpiVwLPGmEXAbuBcBzMOqN21rTy6rITHV+wiOTqcxxbNJTspyulYIiIBqU9Fm2/0MMha29RjJPF2/jOS+BuGyEjiH9/cQkxECIvnj6GxvZMnVuzm1Kkj+Z8zJ3PcHz6gw+Pl2asPZ3p2gtNRRUTEYdbaYmBaL+21wILBTzS4PthazVWPFuL1WhYelsEvTp9ESowGNEVEvq6+HmkbFiOJtc0u7nl/BxY4bkI6T67YTbPLzdXz80iICuO1HxxFVGiILg4qIiLD3tubKvnek6sZmxrDQ5fPZkR8hNORREQCXp+KtuEykvjy2nLcXktEaBDff2oNm/c2csm8UUzJjAcgIz7S4YQiIiLOaevw8HZRJY8uK2FlST0TRsTyxJVzSYwOczqaiMiQMFBL/g8pz68qY2pWPAunZHDnPzeTmRDJTQsnOB1LRETEcS+uLuPWlzfS7HIzMj6CX54xmW/PztaCIyIi/UhFWy9Kalr4/Ztb+OeGvRw7PpVNFY3cfuZkzivIprS+lXNnZREdrl0nIiLDk9drWVfWwNOflPJMYSlzRydxw/HjmDM6ieAgrZ4sItLfVHkcpLyhjVP/8i+8Fk6aMoK3N1USFhLE6VNHEhEazK/PPszpiCIiIo4prm7mB0+vYcOeRoKDDFcdPZqfnDyBkOD+uIqQiIj0RkXbQX79ehFur+WNG+aTmxJNZWM7dS0dmpcvIiLD3qvry/nv59cTFhLEnd86jJMmjyAhSv2jiMhAU9EG1DS7eH9LNZ0eL6+ur+D6BfnkpkQDkB4XQXqcVr4SEZHhy+3x8pd3tvGXd7dTMCqR/71whhbhEhEZRCragN/+czPPFpYBkJkQyTXHjHE4kYiIiH9YtqOW25ZuZEtlE+fOyuKOs6cQHqJFRkREBtOwL9qa2jt5ZV0Fp08byXkFWYxKiiYyTJ2RiIjIsh21XPLgCjISIrjnopksnDIC37VZRURkEA37ou3V9RW0dXr4zpG5zMxJdDqOiIiIX9hd28r3nljFqOQoXrr2SOIiQp2OJCIybA37ou3plaWMS49hRnaC01FEREQc5/Fanlixiz+8uRWABy+brYJNRMRhw7Joc7k9nP6//6a4ugW313LLaZM03UNERIY9j9dy/dNreHV9BUeMSeaXZ0zuXphLREScM+SLNrfHy6PLdnH2jMzuZfv/sWYPWyubuXBuDumxEZw/O9vhlCIiIs6y1vKTF9bz6voKblo4gavn52lAU0TETwz5ou2TnXXc/uomXv+0gieumktIUBD3f1DM5JFx/OqsKeqQREREgGdWlvL8qjKuX5CvVZRFRPzMkC/a1pY1AFC4q57vP7mGCSNiKa5p4e4LZ6hgExERAaoa2/nV60XMy0vihuPznY4jIiIHGfJF27rSBnKTozhvdja/e2MLb26qZHRKNAunZDgdTURExHHWWm55eQMut5f/982pGtAUEfFDw6Bo28fcvCS+d+xYLp43itK6VtJiIwgOUqckIiLy0EclvLGxkptPmcBoLToiIuKXhnTRtndfO3sb25mW1bWcf1xEKJNHxjucSkRExD8s21HLr18v4sRJ6Vx1dJ7TcURE5BCCnA4wkNb5zmebpmuwiYjIIDLGZBtj3jPGFBljNhpjrve132aM2WOMWev7OsWpjB9sreaKh1cyKjmK3583TdMiRUT82JA80lbV1E5dSwfrShsICTJMHhnndCQRERle3MCN1trVxphYYJUx5i3f9+6y1v7ewWy8t6WKxY8WMjYtlkeu0MWzRUT83dcu2owx2cCjwAjACyyx1v7ZGHMbcBVQ7dv0Zmvt630N+lVc/9RalhXXEhsewoSMWCJCgwfz14uIyDBnra0AKnz3m4wxRUCms6m6bKts4vtPrmFceixPXjWP+EgVbCIi/q4v0yP3jyJOBOYB1xpjJvm+d5e1drrva1ALtuLqZpYV1zIjJ4F2t4fD85IH89eLiIgcwBiTC8wAVviarjPGrDfGPGSMSRzMLNurmln0SCERocH87dICFWwiIgHiax9p87dRxHWlDUzNiueZlaWEBBnuv2QWIUFBRIXpKJuIiDjDGBMDvADcYK1tNMbcC/wPYH23fwCu6OV5i4HFADk5Of2S5dnCUm59eQORocE8dPlsRiZE9svPFRGRgdcv57QdNIp4JF2jiJcChXQdjavvj99zKBv27OOsez5iwYQ01uxuYMHENNJiIwbyV4qIiHwuY0woXQXbE9baFwGstZU9vv834NXenmutXQIsASgoKLB9yWGt5a63t/GXd7ZxxJhk7vr2dNLj1EeKiASSPq8eefAoInAvMAaYTteRuD8c4nmLjTGFxpjC6urq3jb50iZlxPHzUyfx4bYaals6OH9O/4xKioiIfB2maynGB4Eia+0fe7Rn9NjsbGDDQGf51WtF/OWdbZxXkMWjV8xRwSYiEoD6dKTNX0YRg4IMi44azfz8FD7eUcsx+al9+XEiIiJ9dSRwCfCpMWatr+1m4AJjzHS6pkeWAFcPdJDjJqQRGRbMj04Yp2X9RUQCVF9WjzzkKKLvfDcYpFHE/fLTY8lPjx2sXyciItIra+2/gd4qpEFdnAvgiLEpHDE2ZbB/rYiI9KO+HGnzm1FEERERERGRoaovq0f6zSiiiIiIiIjIUNXnhUhERERERERk4KhoExERERER8WMq2kRERERERPyYijYRERERERE/pqJNRERERETEjxlr+3Rd6/4JYUw1sKsfflQKUNMPP2cwBFJWCKy8yjpwAilvIGWFwMrb16yjrLWp/RVmqOunPjKQ3l8QWHkDKSsEVl5lHTiBlDeQskLf8h6yf/SLoq2/GGMKrbUFTuf4MgIpKwRWXmUdOIGUN5CyQmDlDaSs0iXQXrNAyhtIWSGw8irrwAmkvIGUFQYur6ZHioiIiIiI+DEVbSIiIiIiIn5sqBVtS5wO8BUEUlYIrLzKOnACKW8gZYXAyhtIWaVLoL1mgZQ3kLJCYOVV1oETSHkDKSsMUN4hdU6biIiIiIjIUDPUjrSJiIiIiIgMKUOiaDPGnGyM2WKM2W6MucnpPD0ZY7KNMe8ZY4qMMRuNMdf72m8zxuwxxqz1fZ3idNb9jDElxphPfbkKfW1Jxpi3jDHbfLeJfpBzfI/9t9YY02iMucGf9q0x5iFjTJUxZkOPtl73penyF9/7eL0xZqYfZP2dMWazL89LxpgEX3uuMaatxz6+bzCzfk7eQ772xpif+vbtFmPMSX6Q9ZkeOUuMMWt97f6wbw/1ueWX7135fOoj+5f6yH7NqD5y8LL6Zf/4OXn9so90tH+01gb0FxAM7ADygDBgHTDJ6Vw98mUAM333Y4GtwCTgNuC/nM53iMwlQMpBbb8FbvLdvwm40+mcvbwP9gKj/GnfAvOBmcCGL9qXwCnA/wEGmAes8IOsJwIhvvt39sia23M7P9q3vb72vn9z64BwYLTvMyPYyawHff8PwK1+tG8P9bnll+9dfX3ua6k+sv8zq4/sv1zqIwcvq1/2j4fKe9D3/aaPdLJ/HApH2uYA2621xdbaDuBp4EyHM3Wz1lZYa1f77jcBRUCms6m+ljOBR3z3HwHOcjBLbxYAO6y1/XGR9n5jrf0QqDuo+VD78kzgUdtlOZBgjMkYnKS9Z7XWvmmtdfseLgeyBivPFznEvj2UM4GnrbUua+1OYDtdnx2D4vOyGmMMcB7w1GDl+SKf87nll+9d+VzqIweH+sivQX3kwAik/hECq490sn8cCkVbJlDa43EZfvqBb4zJBWYAK3xN1/kOlT7kD1MperDAm8aYVcaYxb62dGttBXS9YYE0x9L17nwO/Aftr/sWDr0v/f29fAVdo0X7jTbGrDHGfGCMOdqpUL3o7bX35317NFBprd3Wo81v9u1Bn1uB+t4dzgLmtVEfOaDURw68QOgjA61/BD/uIwe7fxwKRZvppc3vlsQ0xsQALwA3WGsbgXuBMcB0oIKuQ7/+4khr7UxgIXCtMWa+04E+jzEmDDgDeM7X5M/79vP47XvZGPMzwA084WuqAHKstTOAHwFPGmPinMrXw6Fee7/dt8AFHPifKb/Zt718bh1y017a/GX/DncB8dqojxw46iMHXoD0kYHYP4Kf9pFO9I9DoWgrA7J7PM4Cyh3K0itjTChdL+wT1toXAay1ldZaj7XWC/yNQT4U/XmsteW+2yrgJbqyVe4/nOu7rXIu4WcsBFZbayvBv/etz6H2pV++l40xlwGnARdZ3wRt3zSKWt/9VXTNgR/nXMoun/Pa++u+DQG+CTyzv81f9m1vn1sE2HtXgAB4bdRHDjj1kQMoUPrIQOsfwX/7SKf6x6FQtK0E8o0xo32jSecDSx3O1M03F/dBoMha+8ce7T3ns54NbDj4uU4wxkQbY2L336frJNsNdO3Ty3ybXQa87EzCXh0wCuOv+7aHQ+3LpcClvpWG5gH79h9qd4ox5mTgJ8AZ1trWHu2pxphg3/08IB8odiblf3zOa78UON8YE26MGU1X3k8GO18vjgc2W2vL9jf4w7491OcWAfTelW7qI/uR+shBETCfM4HURwZg/wh+2Ec62j9ah1Zf6c8vulZm2UpXtf0zp/MclO0oug6DrgfW+r5OAR4DPvW1LwUynM7qy5tH1ypC64CN+/cnkAy8A2zz3SY5ndWXKwqoBeJ7tPnNvqWro6wAOukabVl0qH1J1yH0v/rex58CBX6QdTtdc7H3v3fv8237Ld/7Yx2wGjjdT/btIV974Ge+fbsFWOh0Vl/7w8A1B23rD/v2UJ9bfvne1dcXvp7qI/svr/rI/s2nPnLwsvpl/3iovL52v+sjnewfje8HioiIiIiIiB8aCtMjRUREREREhiwVbSIiIiIiIn5MRZuIiIiIiIgfU9EmIiIiIiLix1S0iYiIiIiI+DEVbSIiIiIiIn5MRZuIiIiIiIgfU9EmIiIiIiLix/4/tMYcn6cE4d4AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1080x576 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rewards, average, d, h, loss = run_upside_down(max_episodes=200)\n",
    "plt.figure(figsize=(15,8))\n",
    "plt.subplot(2,2,1)\n",
    "plt.title(\"Rewards\")\n",
    "plt.plot(rewards, label=\"rewards\")\n",
    "plt.plot(average, label=\"average100\")\n",
    "plt.legend()\n",
    "plt.subplot(2,2,2)\n",
    "plt.title(\"Loss\")\n",
    "plt.plot(loss)\n",
    "plt.subplot(2,2,3)\n",
    "plt.title(\"desired Rewards\")\n",
    "plt.plot(d)\n",
    "plt.subplot(2,2,4)\n",
    "plt.title(\"desired Horizon\")\n",
    "plt.plot(h)\n",
    "plt.show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SAVE MODEL\n",
    "name = \"model.pth\"\n",
    "torch.save(bf.state_dict(), name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 190,
   "metadata": {},
   "outputs": [],
   "source": [
    "## OBSERVE THE WEIGHTS after training\n",
    "#for p in bf.parameters():\n",
    "#    print(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## EVALUATION RUN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Desired rewards: 200.0 | after finishing one episode the agent received 200.0 rewards\n"
     ]
    }
   ],
   "source": [
    "DESIRED_REWARD = torch.FloatTensor([200]).to(device)\n",
    "DESIRED_HORIZON = torch.FloatTensor([200]).to(device)\n",
    "desired = DESIRED_REWARD.item()\n",
    "\n",
    "env = gym.make('CartPole-v0')\n",
    "env.reset()\n",
    "rewards = 0\n",
    "while True:\n",
    "    all_x = torch.cat((torch.from_numpy(state).float().to(device),DESIRED_REWARD*return_scale,DESIRED_HORIZON*horizon_scale), dim=-1)\n",
    "\n",
    "    probs_logits = bf(all_x)\n",
    "    probs = torch.softmax(probs_logits, dim=-1).detach().cpu()\n",
    "    action = torch.argmax(probs).item()\n",
    "    state, reward, done, info = env.step(action)\n",
    "    rewards += reward\n",
    "    DESIRED_REWARD -= reward\n",
    "    DESIRED_HORIZON -= 1\n",
    "    if done:\n",
    "        break\n",
    "\n",
    "print(\"Desired rewards: {} | after finishing one episode the agent received {} rewards\".format(desired, rewards))\n",
    "env.close()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
